Skip to content

The open-source AI voice studio. Clone, dictate, create.

feat: add Chatterbox Turbo engine and per-engine language lists

James Pinebf728a780c97
diff --git a/app/src/components/Generation/FloatingGenerateBox.tsx b/app/src/components/Generation/FloatingGenerateBox.tsx
index d4ab574d..8a8512f9 100644
--- a/app/src/components/Generation/FloatingGenerateBox.tsx
+++ b/app/src/components/Generation/FloatingGenerateBox.tsx
@@ -13,7 +13,7 @@ import {
} from '@/components/ui/select';
import { Textarea } from '@/components/ui/textarea';
import { useToast } from '@/components/ui/use-toast';
-import { LANGUAGE_OPTIONS } from '@/lib/constants/languages';
+import { getLanguageOptionsForEngine } from '@/lib/constants/languages';
import { useGenerationForm } from '@/lib/hooks/useGenerationForm';
import { useProfile, useProfiles } from '@/lib/hooks/useProfiles';
import { useAddStoryItem, useStory } from '@/lib/hooks/useStories';
@@ -381,25 +381,30 @@ export function FloatingGenerateBox({
<FormField
control={form.control}
name="language"
- render={({ field }) => (
- <FormItem className="flex-1 space-y-0">
- <Select onValueChange={field.onChange} defaultValue={field.value}>
- <FormControl>
- <SelectTrigger className="h-8 text-xs bg-card border-border rounded-full hover:bg-background/50 transition-all">
- <SelectValue />
- </SelectTrigger>
- </FormControl>
- <SelectContent>
- {LANGUAGE_OPTIONS.map((lang) => (
- <SelectItem key={lang.value} value={lang.value} className="text-xs">
- {lang.label}
- </SelectItem>
- ))}
- </SelectContent>
- </Select>
- <FormMessage className="text-xs" />
- </FormItem>
- )}
+ render={({ field }) => {
+ const engineLangs = getLanguageOptionsForEngine(
+ form.watch('engine') || 'qwen',
+ );
+ return (
+ <FormItem className="flex-1 space-y-0">
+ <Select onValueChange={field.onChange} value={field.value}>
+ <FormControl>
+ <SelectTrigger className="h-8 text-xs bg-card border-border rounded-full hover:bg-background/50 transition-all">
+ <SelectValue />
+ </SelectTrigger>
+ </FormControl>
+ <SelectContent>
+ {engineLangs.map((lang) => (
+ <SelectItem key={lang.value} value={lang.value} className="text-xs">
+ {lang.label}
+ </SelectItem>
+ ))}
+ </SelectContent>
+ </Select>
+ <FormMessage className="text-xs" />
+ </FormItem>
+ );
+ }}
/>
<FormItem className="flex-1 space-y-0">
@@ -409,13 +414,19 @@ export function FloatingGenerateBox({
? 'luxtts'
: form.watch('engine') === 'chatterbox'
? 'chatterbox'
- : `qwen:${form.watch('modelSize') || '1.7B'}`
+ : form.watch('engine') === 'chatterbox_turbo'
+ ? 'chatterbox_turbo'
+ : `qwen:${form.watch('modelSize') || '1.7B'}`
}
onValueChange={(value) => {
if (value === 'luxtts') {
form.setValue('engine', 'luxtts');
+ form.setValue('language', 'en');
} else if (value === 'chatterbox') {
form.setValue('engine', 'chatterbox');
+ } else if (value === 'chatterbox_turbo') {
+ form.setValue('engine', 'chatterbox_turbo');
+ form.setValue('language', 'en');
} else {
const [, modelSize] = value.split(':');
form.setValue('engine', 'qwen');
@@ -441,6 +452,12 @@ export function FloatingGenerateBox({
<SelectItem value="chatterbox" className="text-xs text-muted-foreground">
Chatterbox
</SelectItem>
+ <SelectItem
+ value="chatterbox_turbo"
+ className="text-xs text-muted-foreground"
+ >
+ Chatterbox Turbo
+ </SelectItem>
</SelectContent>
</Select>
</FormItem>
diff --git a/app/src/components/Generation/GenerationForm.tsx b/app/src/components/Generation/GenerationForm.tsx
index 26fd13e3..a3c96cbc 100644
--- a/app/src/components/Generation/GenerationForm.tsx
+++ b/app/src/components/Generation/GenerationForm.tsx
@@ -19,7 +19,7 @@ import {
SelectValue,
} from '@/components/ui/select';
import { Textarea } from '@/components/ui/textarea';
-import { LANGUAGE_OPTIONS } from '@/lib/constants/languages';
+import { getLanguageOptionsForEngine } from '@/lib/constants/languages';
import { useGenerationForm } from '@/lib/hooks/useGenerationForm';
import { useProfile } from '@/lib/hooks/useProfiles';
import { useUIStore } from '@/stores/uiStore';
@@ -109,13 +109,19 @@ export function GenerationForm() {
? 'luxtts'
: form.watch('engine') === 'chatterbox'
? 'chatterbox'
- : `qwen:${form.watch('modelSize') || '1.7B'}`
+ : form.watch('engine') === 'chatterbox_turbo'
+ ? 'chatterbox_turbo'
+ : `qwen:${form.watch('modelSize') || '1.7B'}`
}
onValueChange={(value) => {
if (value === 'luxtts') {
form.setValue('engine', 'luxtts');
+ form.setValue('language', 'en');
} else if (value === 'chatterbox') {
form.setValue('engine', 'chatterbox');
+ } else if (value === 'chatterbox_turbo') {
+ form.setValue('engine', 'chatterbox_turbo');
+ form.setValue('language', 'en');
} else {
const [, modelSize] = value.split(':');
form.setValue('engine', 'qwen');
@@ -133,40 +139,46 @@ export function GenerationForm() {
<SelectItem value="qwen:0.6B">Qwen3-TTS 0.6B</SelectItem>
<SelectItem value="luxtts">LuxTTS</SelectItem>
<SelectItem value="chatterbox">Chatterbox</SelectItem>
+ <SelectItem value="chatterbox_turbo">Chatterbox Turbo</SelectItem>
</SelectContent>
</Select>
<FormDescription>
{form.watch('engine') === 'luxtts'
? 'Fast, English-focused'
: form.watch('engine') === 'chatterbox'
- ? 'Multilingual, incl. Hebrew'
- : 'Multi-language, two sizes'}
+ ? '23 languages, incl. Hebrew'
+ : form.watch('engine') === 'chatterbox_turbo'
+ ? 'English, [laugh] [cough] tags'
+ : 'Multi-language, two sizes'}
</FormDescription>
</FormItem>
<FormField
control={form.control}
name="language"
- render={({ field }) => (
- <FormItem>
- <FormLabel>Language</FormLabel>
- <Select onValueChange={field.onChange} defaultValue={field.value}>
- <FormControl>
- <SelectTrigger>
- <SelectValue />
- </SelectTrigger>
- </FormControl>
- <SelectContent>
- {LANGUAGE_OPTIONS.map((lang) => (
- <SelectItem key={lang.value} value={lang.value}>
- {lang.label}
- </SelectItem>
- ))}
- </SelectContent>
- </Select>
- <FormMessage />
- </FormItem>
- )}
+ render={({ field }) => {
+ const engineLangs = getLanguageOptionsForEngine(form.watch('engine') || 'qwen');
+ return (
+ <FormItem>
+ <FormLabel>Language</FormLabel>
+ <Select onValueChange={field.onChange} value={field.value}>
+ <FormControl>
+ <SelectTrigger>
+ <SelectValue />
+ </SelectTrigger>
+ </FormControl>
+ <SelectContent>
+ {engineLangs.map((lang) => (
+ <SelectItem key={lang.value} value={lang.value}>
+ {lang.label}
+ </SelectItem>
+ ))}
+ </SelectContent>
+ </Select>
+ <FormMessage />
+ </FormItem>
+ );
+ }}
/>
<FormField
diff --git a/app/src/lib/api/types.ts b/app/src/lib/api/types.ts
index 9819e00a..fe5f05a1 100644
--- a/app/src/lib/api/types.ts
+++ b/app/src/lib/api/types.ts
@@ -34,7 +34,7 @@ export interface GenerationRequest {
language: LanguageCode;
seed?: number;
model_size?: '1.7B' | '0.6B';
- engine?: 'qwen' | 'luxtts' | 'chatterbox';
+ engine?: 'qwen' | 'luxtts' | 'chatterbox' | 'chatterbox_turbo';
instruct?: string;
}
diff --git a/app/src/lib/constants/languages.ts b/app/src/lib/constants/languages.ts
index 9c85aafd..19d6bca6 100644
--- a/app/src/lib/constants/languages.ts
+++ b/app/src/lib/constants/languages.ts
@@ -1,27 +1,86 @@
/**
- * Supported languages for voice generation.
- * Most languages use Qwen3-TTS; Hebrew uses Chatterbox TTS.
+ * Supported languages for voice generation, per engine.
+ *
+ * Qwen3-TTS supports 10 languages.
+ * LuxTTS is English-only.
+ * Chatterbox Multilingual supports 23 languages.
+ * Chatterbox Turbo is English-only.
*/
-export const SUPPORTED_LANGUAGES = {
- zh: 'Chinese',
+/** All languages that any engine supports. */
+export const ALL_LANGUAGES = {
+ ar: 'Arabic',
+ da: 'Danish',
+ de: 'German',
+ el: 'Greek',
en: 'English',
+ es: 'Spanish',
+ fi: 'Finnish',
+ fr: 'French',
+ he: 'Hebrew',
+ hi: 'Hindi',
+ it: 'Italian',
ja: 'Japanese',
ko: 'Korean',
- de: 'German',
- fr: 'French',
- ru: 'Russian',
+ ms: 'Malay',
+ nl: 'Dutch',
+ no: 'Norwegian',
+ pl: 'Polish',
pt: 'Portuguese',
- es: 'Spanish',
- it: 'Italian',
- he: 'Hebrew',
+ ru: 'Russian',
+ sv: 'Swedish',
+ sw: 'Swahili',
+ tr: 'Turkish',
+ zh: 'Chinese',
} as const;
-export type LanguageCode = keyof typeof SUPPORTED_LANGUAGES;
+export type LanguageCode = keyof typeof ALL_LANGUAGES;
+
+/** Per-engine supported language codes. */
+export const ENGINE_LANGUAGES: Record<string, readonly LanguageCode[]> = {
+ qwen: ['zh', 'en', 'ja', 'ko', 'de', 'fr', 'ru', 'pt', 'es', 'it'],
+ luxtts: ['en'],
+ chatterbox: [
+ 'ar',
+ 'da',
+ 'de',
+ 'el',
+ 'en',
+ 'es',
+ 'fi',
+ 'fr',
+ 'he',
+ 'hi',
+ 'it',
+ 'ja',
+ 'ko',
+ 'ms',
+ 'nl',
+ 'no',
+ 'pl',
+ 'pt',
+ 'ru',
+ 'sv',
+ 'sw',
+ 'tr',
+ 'zh',
+ ],
+ chatterbox_turbo: ['en'],
+} as const;
-export const LANGUAGE_CODES = Object.keys(SUPPORTED_LANGUAGES) as LanguageCode[];
+/** Helper: get language options for a given engine. */
+export function getLanguageOptionsForEngine(engine: string) {
+ const codes = ENGINE_LANGUAGES[engine] ?? ENGINE_LANGUAGES.qwen;
+ return codes.map((code) => ({
+ value: code,
+ label: ALL_LANGUAGES[code],
+ }));
+}
+// ── Backwards-compatible exports used elsewhere ──────────────────────
+export const SUPPORTED_LANGUAGES = ALL_LANGUAGES;
+export const LANGUAGE_CODES = Object.keys(ALL_LANGUAGES) as LanguageCode[];
export const LANGUAGE_OPTIONS = LANGUAGE_CODES.map((code) => ({
value: code,
- label: SUPPORTED_LANGUAGES[code],
+ label: ALL_LANGUAGES[code],
}));
diff --git a/app/src/lib/hooks/useGenerationForm.ts b/app/src/lib/hooks/useGenerationForm.ts
index ec5b9d6a..5a83ce41 100644
--- a/app/src/lib/hooks/useGenerationForm.ts
+++ b/app/src/lib/hooks/useGenerationForm.ts
@@ -16,7 +16,7 @@ const generationSchema = z.object({
seed: z.number().int().optional(),
modelSize: z.enum(['1.7B', '0.6B']).optional(),
instruct: z.string().max(500).optional(),
- engine: z.enum(['qwen', 'luxtts', 'chatterbox']).optional(),
+ engine: z.enum(['qwen', 'luxtts', 'chatterbox', 'chatterbox_turbo']).optional(),
});
export type GenerationFormValues = z.infer<typeof generationSchema>;
@@ -75,15 +75,19 @@ export function useGenerationForm(options: UseGenerationFormOptions = {}) {
? 'luxtts'
: engine === 'chatterbox'
? 'chatterbox-tts'
- : `qwen-tts-${data.modelSize}`;
+ : engine === 'chatterbox_turbo'
+ ? 'chatterbox-turbo'
+ : `qwen-tts-${data.modelSize}`;
const displayName =
engine === 'luxtts'
? 'LuxTTS'
: engine === 'chatterbox'
? 'Chatterbox TTS'
- : data.modelSize === '1.7B'
- ? 'Qwen TTS 1.7B'
- : 'Qwen TTS 0.6B';
+ : engine === 'chatterbox_turbo'
+ ? 'Chatterbox Turbo'
+ : data.modelSize === '1.7B'
+ ? 'Qwen TTS 1.7B'
+ : 'Qwen TTS 0.6B';
try {
const modelStatus = await apiClient.getModelStatus();
diff --git a/backend/backends/__init__.py b/backend/backends/__init__.py
index a7b4d54c..f120e6ec 100644
--- a/backend/backends/__init__.py
+++ b/backend/backends/__init__.py
@@ -122,6 +122,7 @@ TTS_ENGINES = {
"qwen": "Qwen TTS",
"luxtts": "LuxTTS",
"chatterbox": "Chatterbox TTS",
+ "chatterbox_turbo": "Chatterbox Turbo",
}
@@ -171,6 +172,9 @@ def get_tts_backend_for_engine(engine: str) -> TTSBackend:
elif engine == "chatterbox":
from .chatterbox_backend import ChatterboxTTSBackend
backend = ChatterboxTTSBackend()
+ elif engine == "chatterbox_turbo":
+ from .chatterbox_turbo_backend import ChatterboxTurboTTSBackend
+ backend = ChatterboxTurboTTSBackend()
else:
raise ValueError(f"Unknown TTS engine: {engine}. Supported: {list(TTS_ENGINES.keys())}")
diff --git a/backend/backends/chatterbox_turbo_backend.py b/backend/backends/chatterbox_turbo_backend.py
new file mode 100644
index 00000000..16bb5d70
--- /dev/null
+++ b/backend/backends/chatterbox_turbo_backend.py
@@ -0,0 +1,307 @@
+"""
+Chatterbox Turbo TTS backend implementation.
+
+Wraps ChatterboxTurboTTS from chatterbox-tts for fast, English-only
+voice cloning with paralinguistic tag support ([laugh], [cough], etc.).
+Forces CPU on macOS due to known MPS tensor issues.
+"""
+
+import asyncio
+import logging
+import platform
+import threading
+from pathlib import Path
+from typing import ClassVar, List, Optional, Tuple
+
+import numpy as np
+
+from . import TTSBackend
+from ..utils.audio import normalize_audio, load_audio
+from ..utils.progress import get_progress_manager
+from ..utils.tasks import get_task_manager
+
+logger = logging.getLogger(__name__)
+
+CHATTERBOX_TURBO_HF_REPO = "ResembleAI/chatterbox-turbo"
+
+# Files that must be present for the turbo model
+_TURBO_WEIGHT_FILES = [
+ "t3_turbo_v1.safetensors",
+ "s3gen_meanflow.safetensors",
+ "ve.safetensors",
+]
+
+
+class ChatterboxTurboTTSBackend:
+ """Chatterbox Turbo TTS backend — fast, English-only, with paralinguistic tags."""
+
+ # Class-level lock for torch.load monkey-patching
+ _load_lock: ClassVar[threading.Lock] = threading.Lock()
+
+ def __init__(self):
+ self.model = None
+ self.model_size = "default"
+ self._device = None
+ self._model_load_lock = asyncio.Lock()
+
+ def _get_device(self) -> str:
+ """Get the best available device. Forces CPU on macOS (MPS issue)."""
+ if platform.system() == "Darwin":
+ return "cpu"
+ try:
+ import torch
+
+ if torch.cuda.is_available():
+ return "cuda"
+ except ImportError:
+ pass
+ return "cpu"
+
+ def is_loaded(self) -> bool:
+ return self.model is not None
+
+ def _get_model_path(self, model_size: str = "default") -> str:
+ return CHATTERBOX_TURBO_HF_REPO
+
+ def _is_model_cached(self, model_size: str = "default") -> bool:
+ """Check if the Chatterbox Turbo model is cached locally."""
+ try:
+ from huggingface_hub import constants as hf_constants
+
+ repo_cache = Path(hf_constants.HF_HUB_CACHE) / (
+ "models--" + CHATTERBOX_TURBO_HF_REPO.replace("/", "--")
+ )
+
+ if not repo_cache.exists():
+ return False
+
+ blobs_dir = repo_cache / "blobs"
+ if blobs_dir.exists() and any(blobs_dir.glob("*.incomplete")):
+ return False
+
+ # Check for turbo weight files
+ snapshots_dir = repo_cache / "snapshots"
+ if snapshots_dir.exists():
+ for fname in _TURBO_WEIGHT_FILES:
+ if not any(snapshots_dir.rglob(fname)):
+ return False
+ return True
+
+ return False
+ except Exception as e:
+ logger.warning(f"Error checking Chatterbox Turbo cache: {e}")
+ return False
+
+ async def load_model(self, model_size: str = "default") -> None:
+ """Load the Chatterbox Turbo model."""
+ if self.model is not None:
+ return
+ async with self._model_load_lock:
+ if self.model is not None:
+ return
+ await asyncio.to_thread(self._load_model_sync)
+
+ def _load_model_sync(self):
+ """Synchronous model loading."""
+ from ..utils.hf_progress import HFProgressTracker, create_hf_progress_callback
+
+ progress_manager = get_progress_manager()
+ task_manager = get_task_manager()
+ model_name = "chatterbox-turbo"
+
+ is_cached = self._is_model_cached()
+
+ # Set up HF progress tracking (intercepts tqdm for file-level progress)
+ progress_callback = create_hf_progress_callback(model_name, progress_manager)
+ tracker = HFProgressTracker(progress_callback, filter_non_downloads=is_cached)
+ tracker_context = tracker.patch_download()
+ tracker_context.__enter__()
+
+ if not is_cached:
+ task_manager.start_download(model_name)
+ progress_manager.update_progress(
+ model_name=model_name,
+ current=0,
+ total=0,
+ filename="Connecting to HuggingFace...",
+ status="downloading",
+ )
+
+ try:
+ device = self._get_device()
+ self._device = device
+
+ logger.info(f"Loading Chatterbox Turbo TTS on {device}...")
+
+ import torch
+ from huggingface_hub import snapshot_download
+ from chatterbox.tts_turbo import ChatterboxTurboTTS
+
+ # Download model files ourselves so we can pass token=None
+ # (upstream from_pretrained passes token=True which requires
+ # a stored HF token even though the repo is public).
+ try:
+ local_path = snapshot_download(
+ repo_id=CHATTERBOX_TURBO_HF_REPO,
+ token=None,
+ allow_patterns=[
+ "*.safetensors", "*.json", "*.txt", "*.pt", "*.model",
+ ],
+ )
+ finally:
+ tracker_context.__exit__(None, None, None)
+
+ # Monkey-patch torch.load for CPU loading. The model's .pt files
+ # were saved on CUDA; from_local() doesn't pass map_location
+ # so loading on CPU fails without this.
+ if device == "cpu":
+ _orig_torch_load = torch.load
+
+ def _patched_load(*args, **kwargs):
+ kwargs.setdefault("map_location", "cpu")
+ return _orig_torch_load(*args, **kwargs)
+
+ with ChatterboxTurboTTSBackend._load_lock:
+ torch.load = _patched_load
+ try:
+ self.model = ChatterboxTurboTTS.from_local(
+ local_path, device,
+ )
+ finally:
+ torch.load = _orig_torch_load
+ else:
+ self.model = ChatterboxTurboTTS.from_local(
+ local_path, device,
+ )
+
+ if not is_cached:
+ progress_manager.mark_complete(model_name)
+ task_manager.complete_download(model_name)
+
+ logger.info("Chatterbox Turbo TTS loaded successfully")
+
+ except ImportError as e:
+ logger.error(
+ "chatterbox-tts package not found. "
+ "Install with: pip install chatterbox-tts"
+ )
+ if not is_cached:
+ progress_manager.mark_error(model_name, str(e))
+ task_manager.error_download(model_name, str(e))
+ raise
+ except Exception as e:
+ logger.error(f"Failed to load Chatterbox Turbo: {e}")
+ if not is_cached:
+ progress_manager.mark_error(model_name, str(e))
+ task_manager.error_download(model_name, str(e))
+ raise
+
+ def unload_model(self) -> None:
+ """Unload model to free memory."""
+ if self.model is not None:
+ device = self._device
+ del self.model
+ self.model = None
+ self._device = None
+ if device == "cuda":
+ import torch
+
+ torch.cuda.empty_cache()
+ logger.info("Chatterbox Turbo unloaded")
+
+ async def create_voice_prompt(
+ self,
+ audio_path: str,
+ reference_text: str,
+ use_cache: bool = True,
+ ) -> Tuple[dict, bool]:
+ """
+ Create voice prompt from reference audio.
+
+ Chatterbox Turbo processes reference audio at generation time, so the
+ prompt just stores the file path.
+ """
+ voice_prompt = {
+ "ref_audio": str(audio_path),
+ "ref_text": reference_text,
+ }
+ return voice_prompt, False
+
+ async def combine_voice_prompts(
+ self,
+ audio_paths: List[str],
+ reference_texts: List[str],
+ ) -> Tuple[np.ndarray, str]:
+ """Combine multiple reference samples."""
+ combined_audio = []
+ for path in audio_paths:
+ audio, _sr = load_audio(path)
+ audio = normalize_audio(audio)
+ combined_audio.append(audio)
+
+ mixed = np.concatenate(combined_audio)
+ mixed = normalize_audio(mixed)
+ combined_text = " ".join(reference_texts)
+ return mixed, combined_text
+
+ async def generate(
+ self,
+ text: str,
+ voice_prompt: dict,
+ language: str = "en",
+ seed: Optional[int] = None,
+ instruct: Optional[str] = None,
+ ) -> Tuple[np.ndarray, int]:
+ """
+ Generate audio using Chatterbox Turbo TTS.
+
+ Supports paralinguistic tags in text: [laugh], [cough], [chuckle], etc.
+
+ Args:
+ text: Text to synthesize (may include paralinguistic tags)
+ voice_prompt: Dict with ref_audio path
+ language: Ignored (Turbo is English-only)
+ seed: Random seed for reproducibility
+ instruct: Unused (protocol compatibility)
+
+ Returns:
+ Tuple of (audio_array, sample_rate)
+ """
+ await self.load_model()
+
+ ref_audio = voice_prompt.get("ref_audio")
+ if ref_audio and not Path(ref_audio).exists():
+ logger.warning(f"Reference audio not found: {ref_audio}")
+ ref_audio = None
+
+ def _generate_sync():
+ import torch
+
+ if seed is not None:
+ torch.manual_seed(seed)
+
+ logger.info("[Chatterbox Turbo] Generating (English)")
+
+ wav = self.model.generate(
+ text,
+ audio_prompt_path=ref_audio,
+ temperature=0.8,
+ top_k=1000,
+ top_p=0.95,
+ repetition_penalty=1.2,
+ )
+
+ # Convert tensor -> numpy
+ if isinstance(wav, torch.Tensor):
+ audio = wav.squeeze().cpu().numpy().astype(np.float32)
+ else:
+ audio = np.asarray(wav, dtype=np.float32)
+
+ sample_rate = (
+ getattr(self.model, "sr", None)
+ or getattr(self.model, "sample_rate", 24000)
+ )
+
+ return audio, sample_rate
+
+ return await asyncio.to_thread(_generate_sync)
diff --git a/backend/main.py b/backend/main.py
index 3d2ec359..d0be9a54 100644
--- a/backend/main.py
+++ b/backend/main.py
@@ -699,6 +699,29 @@ async def generate_speech(
)
await tts_model.load_model()
+ elif engine == "chatterbox_turbo":
+ if not tts_model._is_model_cached():
+ model_name = "chatterbox-turbo"
+
+ async def download_chatterbox_turbo_background():
+ try:
+ await tts_model.load_model()
+ except Exception as e:
+ task_manager.error_download(model_name, str(e))
+
+ task_manager.start_download(model_name)
+ asyncio.create_task(download_chatterbox_turbo_background())
+
+ raise HTTPException(
+ status_code=202,
+ detail={
+ "message": "Chatterbox Turbo model is being downloaded. Please wait and try again.",
+ "model_name": model_name,
+ "downloading": True,
+ },
+ )
+
+ await tts_model.load_model()
# Create voice prompt from profile
voice_prompt = await profiles.create_voice_prompt_for_profile(
@@ -717,7 +740,7 @@ async def generate_speech(
)
# Trim trailing silence/hallucination for Chatterbox output
- if engine == "chatterbox":
+ if engine in ("chatterbox", "chatterbox_turbo"):
from .utils.audio import trim_tts_output
audio = trim_tts_output(audio, sample_rate)
@@ -798,6 +821,13 @@ async def stream_speech(
detail="Chatterbox model is not downloaded yet. Use /generate to trigger a download.",
)
await tts_model.load_model()
+ elif engine == "chatterbox_turbo":
+ if not tts_model._is_model_cached():
+ raise HTTPException(
+ status_code=400,
+ detail="Chatterbox Turbo model is not downloaded yet. Use /generate to trigger a download.",
+ )
+ await tts_model.load_model()
voice_prompt = await profiles.create_voice_prompt_for_profile(
data.profile_id, db, engine=engine,
@@ -812,7 +842,7 @@ async def stream_speech(
)
# Trim trailing silence/hallucination for Chatterbox output
- if engine == "chatterbox":
+ if engine in ("chatterbox", "chatterbox_turbo"):
from .utils.audio import trim_tts_output
audio = trim_tts_output(audio, sample_rate)
@@ -1433,6 +1463,15 @@ async def get_model_status():
except Exception:
return False
+ # Check if Chatterbox Turbo backend is loaded
+ def check_chatterbox_turbo_loaded():
+ try:
+ from .backends import get_tts_backend_for_engine
+ backend = get_tts_backend_for_engine("chatterbox_turbo")
+ return backend.is_loaded()
+ except Exception:
+ return False
+
model_configs = [
{
"model_name": "qwen-tts-1.7B",
@@ -1462,6 +1501,13 @@ async def get_model_status():
"model_size": "default",
"check_loaded": check_chatterbox_loaded,
},
+ {
+ "model_name": "chatterbox-turbo",
+ "display_name": "Chatterbox Turbo (English, Tags)",
+ "hf_repo_id": "ResembleAI/chatterbox-turbo",
+ "model_size": "default",
+ "check_loaded": check_chatterbox_turbo_loaded,
+ },
{
"model_name": "whisper-base",
"display_name": "Whisper Base",
@@ -1668,6 +1714,10 @@ async def trigger_model_download(request: models.ModelDownloadRequest):
"model_size": "default",
"load_func": lambda: get_tts_backend_for_engine("chatterbox").load_model(),
},
+ "chatterbox-turbo": {
+ "model_size": "default",
+ "load_func": lambda: get_tts_backend_for_engine("chatterbox_turbo").load_model(),
+ },
"whisper-base": {
"model_size": "base",
"load_func": lambda: transcribe.get_whisper_model().load_model("base"),
@@ -1790,6 +1840,11 @@ async def delete_model(model_name: str):
"model_size": "default",
"model_type": "chatterbox",
},
+ "chatterbox-turbo": {
+ "hf_repo_id": "ResembleAI/chatterbox-turbo",
+ "model_size": "default",
+ "model_type": "chatterbox_turbo",
+ },
"whisper-base": {
"hf_repo_id": "openai/whisper-base",
"model_size": "base",
@@ -1834,6 +1889,11 @@ async def delete_model(model_name: str):
chatterbox = get_tts_backend_for_engine("chatterbox")
if chatterbox.is_loaded():
chatterbox.unload_model()
+ elif config["model_type"] == "chatterbox_turbo":
+ from .backends import get_tts_backend_for_engine
+ turbo = get_tts_backend_for_engine("chatterbox_turbo")
+ if turbo.is_loaded():
+ turbo.unload_model()
elif config["model_type"] == "whisper":
whisper_model = transcribe.get_whisper_model()
if whisper_model.is_loaded() and whisper_model.model_size == config["model_size"]:
diff --git a/backend/models.py b/backend/models.py
index c46ded58..80d69495 100644
--- a/backend/models.py
+++ b/backend/models.py
@@ -11,7 +11,7 @@ class VoiceProfileCreate(BaseModel):
"""Request model for creating a voice profile."""
name: str = Field(..., min_length=1, max_length=100)
description: Optional[str] = Field(None, max_length=500)
- language: str = Field(default="en", pattern="^(zh|en|ja|ko|de|fr|ru|pt|es|it|he)$")
+ language: str = Field(default="en", pattern="^(zh|en|ja|ko|de|fr|ru|pt|es|it|he|ar|da|el|fi|hi|ms|nl|no|pl|sv|sw|tr)$")
class VoiceProfileResponse(BaseModel):
@@ -57,7 +57,7 @@ class GenerationRequest(BaseModel):
seed: Optional[int] = Field(None, ge=0)
model_size: Optional[str] = Field(default="1.7B", pattern="^(1\\.7B|0\\.6B)$")
instruct: Optional[str] = Field(None, max_length=500)
- engine: Optional[str] = Field(default="qwen", pattern="^(qwen|luxtts|chatterbox)$")
+ engine: Optional[str] = Field(default="qwen", pattern="^(qwen|luxtts|chatterbox|chatterbox_turbo)$")
class GenerationResponse(BaseModel):