Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

Studio: list every runnable audio.cpp-gguf model on its Audio pages (#12818)

Etherlaba956eb357e
diff --git a/studio/backend/core/inference/audio_cpp_models.py b/studio/backend/core/inference/audio_cpp_models.py
index c46c6d40d0f..e7dc37b0c9c 100644
--- a/studio/backend/core/inference/audio_cpp_models.py
+++ b/studio/backend/core/inference/audio_cpp_models.py
@@ -1569,19 +1569,20 @@ def _single_file_variants(files: Sequence[RepoFile], folder: str) -> list[AudioC
rel = gguf.path[len(prefix) :] if gguf.path.startswith(prefix) else gguf.path
sub = rel.rpartition("/")[0]
rows.append((gguf, sub, quant_label(rel)))
- groups: dict[str, list[str]] = {}
- for gguf, sub, quant in rows:
- k = f"{sub}/{quant}" if sub else quant
- groups.setdefault(k.lower(), []).append(Path(gguf.path).name[: -len(".gguf")])
+ # Several models at one quant in one place (Moonshine tiny/small/medium): key each by its distinct words.
+ seen: set[tuple[str, str]] = set()
+ crowded: set[str] = set()
+ for _gguf, sub, quant in rows:
+ if (sub, quant.lower()) in seen:
+ crowded.add(sub)
+ seen.add((sub, quant.lower()))
+ models = {sub: {_model_stem(g.path) for g, s, _q in rows if s == sub} for sub in crowded}
variants = []
for gguf, sub, quant in rows:
key = f"{sub}/{quant}" if sub else quant
label = None
- stems = groups[key.lower()]
- if len(stems) > 1:
- # Several files at one quant in one place (Moonshine tiny, small and medium): the words their
- # names do not share tell them apart, and name the row like a sub-folder would.
- scope = _distinct_part(Path(gguf.path).name[: -len(".gguf")], stems)
+ if sub in crowded:
+ scope = _distinct_part(_model_stem(gguf.path), models[sub])
key = f"{sub}/{scope}/{quant}" if sub else f"{scope}/{quant}"
label = f"{quant} · {scope}"
elif sub:
@@ -1597,11 +1598,21 @@ def _single_file_variants(files: Sequence[RepoFile], folder: str) -> list[AudioC
return variants
+def _model_stem(path: str) -> str:
+ """A GGUF's file name without its quant: ``irodori-tts-v4.1-anime-q8_0.gguf`` -> ``irodori-tts-v4.1-anime``."""
+ stem = Path(path).name[: -len(".gguf")]
+ matches = list(_QUANT_RE.finditer(stem))
+ if not matches:
+ return stem
+ last = matches[-1]
+ return (stem[: last.start()] + stem[last.end() :]).strip("-_.") or stem
+
+
def _distinct_part(stem: str, stems: Sequence[str]) -> str:
- """The words of ``stem`` its siblings do not share: ``moonshine-streaming-tiny-q8_0`` among
- ``...-small-q8_0`` gives ``tiny``. The whole stem when nothing is left."""
- split = [re.split(r"[-_.]", s) for s in stems]
- words = re.split(r"[-_.]", stem)
+ """The words of ``stem`` its siblings do not share: ``moonshine-streaming-tiny`` among
+ ``...-small`` gives ``tiny``. Dots stay inside a word (``v4.1``). The whole stem when nothing is left."""
+ split = [re.split(r"[-_]", s) for s in stems]
+ words = re.split(r"[-_]", stem)
head = 0
while all(len(w) > head for w in split) and len({w[head].lower() for w in split}) == 1:
head += 1
@@ -1637,7 +1648,9 @@ def _variant_rank(variant: AudioCppVariant) -> tuple:
scope_rank = (
0 if not sub else (1 + _PREFERRED_SCOPES.index(sub) if sub in _PREFERRED_SCOPES else 10)
)
- quant = quant_label(variant.main_file)
+ # Q8_0_V2 is a Q8_0 re-export and FP32 is F32 under another name.
+ quant = re.sub(r"_V\d+$", "", quant_label(variant.main_file))
+ quant = {"FP32": "F32", "FP16": "F16"}.get(quant, quant)
quant_rank = (
_QUANT_PREFERENCE.index(quant) if quant in _QUANT_PREFERENCE else len(_QUANT_PREFERENCE)
)
@@ -1650,12 +1663,15 @@ def _variant_rank(variant: AudioCppVariant) -> tuple:
def match_variant(
- variants: Sequence[AudioCppVariant], wanted: Optional[str]
+ variants: Sequence[AudioCppVariant],
+ wanted: Optional[str],
+ folder: str = "",
) -> Optional[AudioCppVariant]:
"""The variant ``wanted`` names: its key, its file, or a quant that picks one row.
A bare quant shared by several rows (ACE-Step ``turbo/Q8_0`` and ``base/Q8_0``) picks the default
- ordering's first, which is what the folder row loads by default.
+ ordering's first, which is what the folder row loads by default. ``folder`` is the row's folder in
+ the repo, whose own name never counts as a scope word.
"""
text = (wanted or "").strip().replace("\\", "/")
if not text:
@@ -1681,10 +1697,14 @@ def match_variant(
scoped = [v for v in variants if v.key.lower().startswith(low + "/")]
if scoped:
return sorted(scoped, key = _variant_rank)[0]
- return _match_by_words(variants, low)
+ return _match_by_words(variants, low, folder)
-def _match_by_words(variants: Sequence[AudioCppVariant], low: str) -> Optional[AudioCppVariant]:
+def _match_by_words(
+ variants: Sequence[AudioCppVariant],
+ low: str,
+ folder: str = "",
+) -> Optional[AudioCppVariant]:
"""A key named by the words of its file (``tiny/Q8_0`` or ``tiny``), whatever the listing keyed it.
Which rows need a name beyond their quant depends on the listing: with only Moonshine tiny in
@@ -1698,10 +1718,21 @@ def _match_by_words(variants: Sequence[AudioCppVariant], low: str) -> Optional[A
scopes = parts[:-1] if quant else parts
if not scopes:
return None
+
+ prefix = f"{folder}/".lower() if folder else ""
+
+ def named(path: str, scope: str) -> bool:
+ # Scope words run together below the row's folder: ``multilingual-ctc`` is not ``multilingual-large-ctc``,
+ # and ``Irodori-TTS-v4-Small-GGUF`` does not make every file in it ``v4-small``.
+ path = path.lower()
+ path = path[len(prefix) :] if prefix and path.startswith(prefix) else path
+ words = "-".join(re.split(r"[-_./]", path))
+ return f"-{'-'.join(re.split(r'[-_.]', scope))}-" in f"-{words}-"
+
matches = [
v
for v in variants
- if all(scope in re.split(r"[-_./]", v.main_file.lower()) for scope in scopes)
+ if all(named(v.main_file, scope) for scope in scopes)
and (quant is None or quant_label(v.main_file).lower() == quant)
]
return sorted(matches, key = _variant_rank)[0] if matches else None
@@ -2262,10 +2293,11 @@ def _resolve_uncached(
network: bool,
tags: tuple[str, ...],
) -> Optional[AudioCppModel]:
+ from_hub = False
if ref.local_path:
files = [RepoFile(Path(ref.local_path).name, _size(ref.local_path))]
else:
- files, _from_hub = list_files(ref.repo_id, ref.folder, hf_token, network = network)
+ files, from_hub = list_files(ref.repo_id, ref.folder, hf_token, network = network)
files = [f for f in files if not _SKIP_FILE_RE.search(f.path)]
ggufs = [f for f in files if f.path.lower().endswith(".gguf")]
if not ggufs:
@@ -2326,27 +2358,32 @@ def _resolve_uncached(
)
variants = [AudioCppVariant(quant_label(ggufs[0].path), (ggufs[0],), ggufs[0].path)]
default = variants[0]
- chosen = match_variant(variants, wanted) if wanted else default
+ chosen = match_variant(variants, wanted, ref.folder) if wanted else default
if (
chosen is not None
and wanted
- and "/" not in chosen.key
+ and (not from_hub or "/" not in chosen.key)
and chosen.key.lower() != wanted.lower()
):
- # A partial cache listing named the row by quant alone; keep the name the full listing gives
- # it (``tiny/Q8_0``), so status and /gguf-variants agree on the variant that is loaded.
+ # A cache-only listing keys the row more loosely (``Q8_0``, ``ctc/F16``): keep the full listing's key.
text = wanted.strip().strip("/")
head, _, tail = text.rpartition("/")
- scope = head if tail.lower() == chosen.key.lower() else ""
- if not scope and re.fullmatch(r"[A-Za-z0-9]+", text) and not _is_quant(text):
+ quant = chosen.key.rpartition("/")[2]
+ scope = head if tail.lower() == quant.lower() else ""
+ if (
+ not scope
+ and "/" not in chosen.key
+ and re.fullmatch(r"[A-Za-z0-9]+", text)
+ and not _is_quant(text)
+ ):
scope = text # a bare sub-variant name ("tiny"), not a quant or a file stem
if scope:
chosen = AudioCppVariant(
- f"{scope}/{chosen.key}",
+ f"{scope}/{quant}",
chosen.files,
chosen.primary,
dict(chosen.session_options),
- f"{chosen.key} · {scope.rsplit('/', 1)[-1]}",
+ f"{quant} · {scope.rsplit('/', 1)[-1]}",
)
if chosen is None:
unsupported = unsupported or (
@@ -2457,6 +2494,24 @@ def package_variant_files(names: Iterable[str]) -> Optional[dict[str, tuple[str,
return None
+def companion_files(path: str, names: Iterable[str]) -> tuple[str, ...]:
+ """The umbrella files the model GGUF at ``path`` loads beside it (MioTTS's MioCodec), from the
+ umbrella's listing ``names``. A pure function of the names, for the GGUF download planner."""
+ folder, sep, _ = path.partition("/")
+ policy = FAMILIES.get(family_from_names((folder,)) or "") if sep else None
+ if policy is None or not policy.companions:
+ return ()
+ names = list(names)
+ found = []
+ for companion in policy.companions:
+ sub = companion.id[len(_UMBRELLA_PREFIX) :]
+ files = [RepoFile(name, 0) for name in names if name.startswith(f"{sub}/")]
+ variant = match_variant(_single_file_variants(files, sub), companion.variant, sub)
+ if variant is not None:
+ found.append(variant.primary)
+ return tuple(found)
+
+
def download_target(
identifier: Optional[str],
variant: Optional[str],
diff --git a/studio/backend/hub/services/models/gguf_variants.py b/studio/backend/hub/services/models/gguf_variants.py
index 560670a5bb0..77b77a237f1 100644
--- a/studio/backend/hub/services/models/gguf_variants.py
+++ b/studio/backend/hub/services/models/gguf_variants.py
@@ -1095,16 +1095,27 @@ async def _audio_cpp_variants_answer(
from core.inference import audio_cpp_files
def _details():
+ companions = [
+ audio_cpp_models.resolve(c.id, c.variant, hf_token, network = network)
+ for c in model.companions
+ ]
+ companions_cached = all(
+ c is not None and audio_cpp_files.cached_files(c) is not None for c in companions
+ )
+ companion_bytes = sum(c.variant.size_bytes for c in companions if c is not None)
rows = []
for variant in model.variants:
- downloaded = audio_cpp_files.cached_files(model.with_variant(variant)) is not None
+ downloaded = (
+ companions_cached
+ and audio_cpp_files.cached_files(model.with_variant(variant)) is not None
+ )
rows.append(
GgufVariantDetail(
filename = variant.main_file,
quant = variant.key,
display_label = variant.label,
size_bytes = variant.size_bytes,
- download_size_bytes = variant.size_bytes,
+ download_size_bytes = variant.size_bytes + companion_bytes,
downloaded = downloaded,
)
)
diff --git a/studio/backend/hub/utils/gguf_plan.py b/studio/backend/hub/utils/gguf_plan.py
index d661bef144e..a7d2e3a0e42 100644
--- a/studio/backend/hub/utils/gguf_plan.py
+++ b/studio/backend/hub/utils/gguf_plan.py
@@ -314,20 +314,33 @@ def _audio_cpp_package_plans(siblings: Sequence) -> Optional[dict[str, GgufVaria
return plans
-def _with_audio_cpp_voices(plan: GgufVariantPlan, siblings: Sequence) -> GgufVariantPlan:
- """*plan* plus the voice embeddings audio.cpp reads beside its GGUF (``<dir>/embeddings/*``), as
- PocketTTS publishes them. A GGUF with no such folder beside it is returned unchanged."""
+def _with_audio_cpp_extras(plan: GgufVariantPlan, siblings: Sequence) -> GgufVariantPlan:
+ """*plan* plus what audio.cpp reads beside its GGUF: the voice embeddings in ``<dir>/embeddings/``
+ (PocketTTS) and a companion model in the same repo (MioTTS's MioCodec). Otherwise unchanged."""
dirs = {name.rpartition("/")[0] for name in plan.main_filenames}
if len(dirs) != 1:
return plan
prefix = f"{next(iter(dirs))}/embeddings/".lstrip("/")
- extras = tuple(
- file
+ by_name = {
+ name: sibling
for sibling in siblings
if isinstance(name := getattr(sibling, "rfilename", None), str)
- and name.startswith(prefix)
- and name.lower().endswith(".safetensors")
- and (file := expected_file_from_sibling(sibling)) is not None
+ }
+ wanted = {
+ name
+ for name in by_name
+ if name.startswith(prefix) and name.lower().endswith(".safetensors")
+ }
+ try:
+ from core.inference.audio_cpp_models import companion_files
+ except Exception:
+ companion_files = None
+ if companion_files is not None:
+ wanted.update(companion_files(min(plan.main_filenames), by_name))
+ extras = tuple(
+ file
+ for name, sibling in by_name.items()
+ if name in wanted and (file := expected_file_from_sibling(sibling)) is not None
)
if not extras:
return plan
@@ -408,7 +421,7 @@ def build_gguf_variant_plans(siblings: Sequence) -> dict[str, GgufVariantPlan]:
*mtp_expected,
*dflash_expected,
)
- plans[quant] = _with_audio_cpp_voices(
+ plans[quant] = _with_audio_cpp_extras(
plan_from_expected_files(
quant,
expected_files,
diff --git a/studio/backend/tests/test_audio_cpp_models.py b/studio/backend/tests/test_audio_cpp_models.py
index 4bf2fe8755c..422d4de10ec 100644
--- a/studio/backend/tests/test_audio_cpp_models.py
+++ b/studio/backend/tests/test_audio_cpp_models.py
@@ -4,6 +4,7 @@
"""audio.cpp GGUFs: recognising them by header, resolving ids and variants, their files in the HF
cache, and the worker backend's request shaping."""
+import asyncio
import base64
import io
import json
@@ -667,6 +668,94 @@ def test_sub_folders_and_same_quant_files_become_named_variants(hub):
).variant.key == ("tiny/Q8_0")
+def _keys(folder, *names):
+ files = [RepoFile(f"{folder}/{name}", 1) for name in names]
+ return [v.key for v in sorted(acm._single_file_variants(files, folder), key = acm._variant_rank)]
+
+
+def test_umbrella_folders_key_and_rank_their_models_by_the_published_names():
+ # Q8_0_V2 is the Q8_0 export and FP32 is F32: both outrank the bigger or unranked files.
+ assert _keys(
+ "Qwen3-TTS-12Hz-1.7B-Base-GGUF",
+ "qwen3-tts-12hz-1.7b-base-bf16.gguf",
+ "qwen3-tts-12hz-1.7b-base-orig.gguf",
+ "qwen3-tts-12hz-1.7b-base-q8_0_v2.gguf",
+ ) == ["Q8_0_V2", "BF16", "orig"]
+ assert _keys(
+ "MeanVC2-GGUF", "meanvc2-120ms-40ms-q4_k.gguf", "meanvc2-120ms-40ms-fp32.gguf"
+ ) == ["FP32", "Q4_K"]
+ # Six models in one folder: an F32 row is named like its F16 sibling.
+ gigaam = [
+ f"gigaam-{name}-f16.gguf"
+ for name in (
+ "multilingual-ctc",
+ "multilingual-large-ctc",
+ "v3-ctc",
+ "v3-e2e-ctc",
+ "v3-e2e-rnnt",
+ "v3-rnnt",
+ )
+ ]
+ assert _keys(
+ "GigaAM-ASR-GGUF",
+ *gigaam,
+ "gigaam-multilingual-ctc-f32.gguf",
+ "gigaam-multilingual-large-ctc-f32.gguf",
+ ) == [
+ "multilingual-ctc/F16",
+ "multilingual-large-ctc/F16",
+ "v3-ctc/F16",
+ "v3-e2e-ctc/F16",
+ "v3-e2e-rnnt/F16",
+ "v3-rnnt/F16",
+ "multilingual-ctc/F32",
+ "multilingual-large-ctc/F32",
+ ]
+ # A dotted version stays one word, and the model with one quant is named too.
+ assert _keys(
+ "Irodori-TTS-v4-Small-GGUF",
+ "irodori-tts-v4-small-f16.gguf",
+ "irodori-tts-v4.1-anime-q8_0.gguf",
+ "irodori-tts-v4-small-q8_0.gguf",
+ ) == ["v4-small/Q8_0", "v4.1-anime/Q8_0", "v4-small/F16"]
+
+
+def test_umbrella_keys_saved_settings_name_stay_the_same():
+ assert _keys(
+ "Moonshine-Streaming-GGUF",
+ "moonshine-streaming-tiny-q8_0.gguf",
+ "moonshine-streaming-medium-q8_0.gguf",
+ "moonshine-streaming-small-q8_0.gguf",
+ ) == ["tiny/Q8_0", "medium/Q8_0", "small/Q8_0"]
+ assert _keys(
+ "Niagara-ASR-GGUF", "niagara-19m-batch.en-f32.gguf", "niagara-38m-batch.en-f32.gguf"
+ ) == ["19m/F32", "38m/F32"]
+ assert _keys(
+ "Samsone-GGUF",
+ *(
+ f"samsone-{size}-{quant}.gguf"
+ for size in ("99m", "134m", "356m")
+ for quant in ("q8_0", "bf16")
+ ),
+ ) == ["134m/Q8_0", "356m/Q8_0", "99m/Q8_0", "134m/BF16", "356m/BF16", "99m/BF16"]
+ assert _keys("UniverSR-GGUF", "universr-audio-orig.gguf", "universr-speech-orig.gguf") == [
+ "audio/orig",
+ "speech/orig",
+ ]
+ assert _keys(
+ "ACE-Step1.5-GGUF",
+ "turbo/ace-step-1.5-turbo-q8_0.gguf",
+ "turbo/ace-step-1.5-turbo-bf16.gguf",
+ "base/ace-step-1.5-base-q8_0.gguf",
+ ) == ["turbo/Q8_0", "turbo/BF16", "base/Q8_0"]
+ assert _keys(
+ "PocketTTS-GGUF",
+ "english/pocket-tts-english-q8_0.gguf",
+ "english/pocket-tts-english-bf16.gguf",
+ "german/pocket-tts-german-q8_0.gguf",
+ ) == ["english/Q8_0", "english/BF16", "german/Q8_0"]
+
+
def _minimax(root, *, quant = "q4_0"):
snap = _snapshot(root, "audio-cpp/MiniMax-Music3-GGUF")
header = _gguf_bytes(family = "minimax_music3")
@@ -758,6 +847,123 @@ def test_voice_embeddings_ride_with_the_gguf_they_sit_beside():
assert english.download_size_bytes == 15
+GIGAAM_FILES = (
+ *(
+ f"gigaam-{name}-f16.gguf"
+ for name in (
+ "multilingual-ctc",
+ "multilingual-large-ctc",
+ "v3-ctc",
+ "v3-e2e-ctc",
+ "v3-e2e-rnnt",
+ "v3-rnnt",
+ )
+ ),
+ "gigaam-multilingual-ctc-f32.gguf",
+ "gigaam-multilingual-large-ctc-f32.gguf",
+)
+GIGAAM_SPEC = {"family": "gigaam_asr", "tasks": ["asr"]}
+
+
+ "folder, spec, published, cached",
+ [
+ ("GigaAM-ASR-GGUF", GIGAAM_SPEC, GIGAAM_FILES, GIGAAM_FILES[2:3]),
+ ("GigaAM-ASR-GGUF", GIGAAM_SPEC, GIGAAM_FILES, (GIGAAM_FILES[0], GIGAAM_FILES[1])),
+ (
+ "Irodori-TTS-v4-Small-GGUF",
+ {"family": "irodori_tts", "tasks": ["tts"]},
+ (
+ "irodori-tts-v4-small-f16.gguf",
+ "irodori-tts-v4.1-anime-q8_0.gguf",
+ "irodori-tts-v4-small-q8_0.gguf",
+ ),
+ ("irodori-tts-v4-small-q8_0.gguf", "irodori-tts-v4.1-anime-q8_0.gguf"),
+ ),
+ ],
+)
+def test_a_hub_variant_key_loads_its_file_from_a_partial_cache(
+ hub, folder, spec, published, cached
+):
+ # STT loads and offline loads list only the cache, where the downloaded files alone name the rows.
+ online = acm._single_file_variants(
+ [RepoFile(f"{folder}/{name}", 1) for name in published], folder
+ )
+ snap = _snapshot(hub)
+ for name in cached:
+ _put(snap, f"{folder}/{name}", _gguf_bytes(family = spec["family"], spec = spec))
+ for name in cached:
+ key = next(v.key for v in online if v.primary == f"{folder}/{name}")
+ acm.forget()
+ model = acm.resolve(f"{AUDIO_CPP_REPO}/{folder}", key, network = False)
+ assert model.unsupported is None, key
+ assert model.variant.primary == f"{folder}/{name}"
+ assert model.variant.key == key
+
+
+def test_the_folder_name_never_names_a_variant(hub):
+ # Irodori-TTS-v4-Small-GGUF carries the words of v4-small: with only the anime model cached,
+ # v4-small/Q8_0 is missing, not the anime file under that name.
+ folder = "Irodori-TTS-v4-Small-GGUF"
+ spec = {"family": "irodori_tts", "tasks": ["tts"]}
+ _put(
+ _snapshot(hub),
+ f"{folder}/irodori-tts-v4.1-anime-q8_0.gguf",
+ _gguf_bytes(family = "irodori_tts", spec = spec),
+ )
+ model = acm.resolve(f"{AUDIO_CPP_REPO}/{folder}", "v4-small/Q8_0", network = False)
+ assert "not found" in model.unsupported
+ anime = acm.resolve(f"{AUDIO_CPP_REPO}/{folder}", "v4.1-anime/Q8_0", network = False)
+ assert anime.unsupported is None and anime.variant.key == "v4.1-anime/Q8_0"
+
+
+MIOCODEC_Q8 = "MioCodec-25Hz-44.1kHz-v2-GGUF/miocodec-25hz-44khz-v2-q8_0.gguf"
+
+
+def test_miotts_downloads_its_codec_with_every_variant():
+ from hub.utils.gguf_plan import build_gguf_variant_plans, plan_for_variant
+
+ def sib(name):
+ return SimpleNamespace(rfilename = name, size = 5, lfs = {"sha256": name})
+
+ names = [
+ "MioTTS-1.7B-GGUF/miotts-1.7b-q8_0.gguf",
+ "MioTTS-1.7B-GGUF/miotts-1.7b-bf16.gguf",
+ MIOCODEC_Q8,
+ "MioCodec-25Hz-44.1kHz-v2-GGUF/miocodec-25hz-44khz-v2-f16.gguf",
+ "Kokoro-82M-GGUF/kokoro-82m-q8_0.gguf",
+ ]
+ assert acm.companion_files(names[1], names) == (MIOCODEC_Q8,)
+ assert acm.companion_files(names[4], names) == ()
+ plans = build_gguf_variant_plans([sib(n) for n in names])
+ bf16 = plan_for_variant(plans, "MioTTS-1.7B-GGUF/miotts-1.7b-bf16")
+ assert set(bf16.target_filenames) == {names[1], MIOCODEC_Q8}
+ assert bf16.main_filenames == frozenset({names[1]}) and bf16.download_size_bytes == 10
+ kokoro = plan_for_variant(plans, "Kokoro-82M-GGUF/kokoro-82m-q8_0")
+ assert kokoro.target_filenames == (names[4],)
+
+
+def test_miotts_lists_as_downloaded_only_with_its_codec(hub):
+ from hub.services.models import gguf_variants as gv
+
+ snap = _snapshot(hub)
+ _put(snap, "MioTTS-1.7B-GGUF/miotts-1.7b-q8_0.gguf", _gguf_bytes(family = "miotts"))
+
+ def answer():
+ acm.forget()
+ result = asyncio.run(
+ gv._audio_cpp_variants_answer(f"{AUDIO_CPP_REPO}/MioTTS-1.7B-GGUF", None, True)
+ )
+ return result.response.variants[0]
+
+ row = answer()
+ assert row.quant == "Q8_0" and not row.downloaded
+ codec = _put(snap, MIOCODEC_Q8, _gguf_bytes(family = "miocodec"))
+ row = answer()
+ assert row.downloaded
+ assert row.download_size_bytes == row.size_bytes + codec.stat().st_size
+
+
def test_download_target_maps_a_folder_row_onto_the_planner_key(hub):
_kokoro(hub)
assert acm.download_target(f"{AUDIO_CPP_REPO}/Kokoro-82M-GGUF", "Q8_0") == (
diff --git a/studio/backend/tests/test_audio_cpp_umbrella_catalog.py b/studio/backend/tests/test_audio_cpp_umbrella_catalog.py
new file mode 100644
index 00000000000..7e5595acb69
--- /dev/null
+++ b/studio/backend/tests/test_audio_cpp_umbrella_catalog.py
@@ -0,0 +1,162 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+"""Every folder of the audio.cpp-gguf repo lands on the Audio pages its family runs on, and the
+Audio pickers offer exactly the folders Studio runs under the pinned runtime."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+import pytest
+
+from core.inference import audio_cpp_models as acm
+from core.inference.audio_cpp_spec_families import AUDIO_CPP_SPEC_FAMILIES
+
+# Folder -> (family its GGUF header names, Audio pages), audio-cpp/audio.cpp-gguf at e36610ac.
+UMBRELLA = {
+ "ACE-Step1.5-GGUF": ("ace_step", ["music"]),
+ "Apollo-GGUF": ("apollo", []),
+ "AudioSR-GGUF": ("audiosr", []),
+ "BS-RoFormer-ep368-GGUF": ("bs_roformer", ["separate"]),
+ "Breeze-TTS-2-GGUF": ("breeze_tts", ["speak"]),
+ "Canary-180M-Flash-GGUF": ("canary_asr", ["transcribe"]),
+ "Chatterbox-GGUF": ("chatterbox", ["clone", "convert"]),
+ "Chatterbox-Turbo-GGUF": ("chatterbox_turbo", ["speak"]),
+ "Citrinet-ASR-GGUF": ("citrinet_asr", ["transcribe"]),
+ "Cohere-Transcribe-GGUF": ("cohere_asr", ["transcribe"]),
+ "Confucius4-TTS-GGUF": ("confucius4_tts", ["clone"]),
+ "ControlFoley-GGUF": ("controlfoley", ["music"]),
+ "CosyVoice3-GGUF": ("cosyvoice3", ["clone"]),
+ "CrisperWhisper2.0-GGUF": ("crisperwhisper", []),
+ "DotTTS-Edit-GGUF": ("dots_tts", ["speak", "edit"]),
+ "DotTTS-MF-GGUF": ("dots_tts", ["speak"]),
+ "DotTTS-SOAR-GGUF": ("dots_tts", ["speak"]),
+ "DramaBox-GGUF": ("dramabox", ["speak"]),
+ "FireRedAudio-GGUF": ("firered_audio", ["clone", "edit"]),
+ "FireRedTTS3-Base-GGUF": ("fireredtts3", ["clone"]),
+ "FireRedTTS3-Instruct-GGUF": ("fireredtts3", ["clone"]),
+ "Fish-Audio-S2-Pro-GGUF": ("fish_audio", ["speak", "clone"]),
+ "Fun-ASR-Nano-2512-GGUF": ("fun_asr_nano", ["transcribe"]),
+ "GigaAM-ASR-GGUF": ("gigaam_asr", ["transcribe"]),
+ "Granite-Speech-5.0-470M-TurboCTC-GGUF": ("granite5asr", ["transcribe"]),
+ "HTDemucs-6stems-GGUF": ("htdemucs_6stems", ["separate"]),
+ "HTDemucs-GGUF": ("htdemucs", ["separate"]),
+ "HeartMuLa-GGUF": ("heartmula", ["music"]),
+ "Higgs-Audio-v3-STT-GGUF": ("higgs_audio_stt", ["transcribe"]),
+ "Higgs-Audio-v3-TTS-4B-GGUF": ("higgs_audio_tts", ["speak"]),
+ "Hviske-v5.3-GGUF": ("hviske_asr", ["transcribe"]),
+ "IndexTTS2-GGUF": ("index_tts2", ["clone"]),
+ "IndexTTS2.5-GGUF": ("index_tts2", ["clone"]),
+ "Inflect-Micro-v2-GGUF": ("inflect_v2", ["speak"]),
+ "Irodori-TTS-500M-v3-GGUF": ("irodori_tts", ["speak"]),
+ "Irodori-TTS-600M-v3-VoiceDesign-GGUF": ("irodori_tts", ["speak"]),
+ "Irodori-TTS-v4-Small-GGUF": ("irodori_tts", ["speak"]),
+ "KittenTTS-GGUF": ("kitten_tts", ["speak"]),
+ "Kokoro-82M-GGUF": ("kokoro_tts", ["speak"]),
+ "Kroko-ASR-GGUF": ("kroko_asr", ["transcribe"]),
+ "KugelAudio-0-Open-GGUF": ("kugelaudio", []),
+ "MMS-Forced-Aligner-GGUF": ("mms_forced_aligner", []),
+ "MOSS-TTS-Local-v1.5-GGUF": ("moss_tts_local", ["speak"]),
+ "MOSS-TTS-Nano-100M-GGUF": ("moss_tts_nano", ["speak"]),
+ "MOSS-Transcribe-Diarize-GGUF": ("moss_transcribe_diarize", ["transcribe"]),
+ "MOSS-VoiceGenerator-GGUF": ("moss_voicegen", ["speak"]),
+ "MagpieTTS-Multilingual-357M-GGUF": ("magpie_tts", ["speak"]),
+ "Maya1-GGUF": ("maya1", ["speak"]),
+ "MeanVC2-GGUF": ("meanvc2", ["convert"]),
+ "Mel-Band-RoFormer-GGUF": ("mel_band_roformer", ["separate"]),
+ "MiDashengLM-Gen-GGUF": ("midashenglm_gen", ["music"]),
+ "MiniMax-H3-Q4-GGUF": ("minimax_h3", []),
+ "MioCodec-25Hz-44.1kHz-v2-GGUF": ("miocodec", []),
+ "MioTTS-1.7B-GGUF": ("miotts", ["clone"]),
+ "Moonshine-Streaming-GGUF": ("moonshine_asr", ["transcribe"]),
+ "MuScriptor-Small-GGUF": ("muscriptor", []),
+ "Nemotron-3.5-ASR-Streaming-0.6B-GGUF": ("nemotron_asr", ["transcribe"]),
+ "NeuTTS-2E-GGUF": ("neutts", ["speak"]),
+ "Niagara-ASR-GGUF": ("niagara_asr", ["transcribe"]),
+ "OWSM-CTC-GGUF": ("owsm_ctc", []),
+ "OWSM-GGUF": ("owsm", []),
+ "OmniVoice-GGUF": ("omnivoice", ["speak"]),
+ "Parakeet-TDT-0.6B-v3-GGUF": ("parakeet_tdt", ["transcribe"]),
+ "PersonaPlex-GGUF": ("personaplex", []),
+ "Piper-TTS-GGUF": ("piper_tts", ["speak"]),
+ "PocketTTS-GGUF": ("pocket_tts", ["speak"]),
+ "PulseVAD-GGUF": ("pulsevad", []),
+ "Qwen3-ASR-0.6B-GGUF": ("qwen3_asr", ["transcribe"]),
+ "Qwen3-ASR-1.7B-GGUF": ("qwen3_asr", ["transcribe"]),
+ "Qwen3-ForcedAligner-0.6B-GGUF": ("qwen3_forced_aligner", []),
+ "Qwen3-TTS-12Hz-0.6B-Base-GGUF": ("qwen3_tts", ["clone"]),
+ "Qwen3-TTS-12Hz-1.7B-Base-GGUF": ("qwen3_tts", ["clone"]),
+ "Qwen3-TTS-12Hz-1.7B-CustomVoice-GGUF": ("qwen3_tts", ["speak"]),
+ "Qwen3-TTS-12Hz-1.7B-VoiceDesign-GGUF": ("qwen3_tts", ["speak"]),
+ "RVC-GGUF": ("rvc", ["convert"]),
+ "Samsone-GGUF": ("samsone", []),
+ "SeedVC-MLX-GGUF": ("seed_vc", ["convert"]),
+ "Sidon-GGUF": ("sidon", []),
+ "Smart-Turn-v3-GGUF": ("smart_turn", []),
+ "Sortformer-Diar-4spk-v1-GGUF": ("sortformer_diar", []),
+ "Stable-Audio-3-Medium-GGUF": ("stable_audio", ["music"]),
+ "Stable-Audio-3-Small-Music-GGUF": ("stable_audio", ["music"]),
+ "Stable-Audio-3-Small-SFX-GGUF": ("stable_audio", ["music"]),
+ "Supertonic-3-GGUF": ("supertonic", ["speak"]),
+ "Tone-Color-VC-GGUF": ("tone_color_vc", []),
+ "UniverSR-GGUF": ("universr", []),
+ "Vevo2-GGUF": ("vevo2", ["clone", "edit", "convert"]),
+ "VibeVoice-1.5B-GGUF": ("vibevoice", ["speak"]),
+ "VibeVoice-ASR-GGUF": ("vibevoice_asr", ["transcribe"]),
+ "VoxCPM1-GGUF": ("voxcpm1", ["speak"]),
+ "VoxCPM2-GGUF": ("voxcpm2", ["speak", "clone"]),
+ "Voxtral-Mini-4B-Realtime-2602-GGUF": ("voxtral_realtime", ["transcribe"]),
+}
+
+# Families outside acm.FAMILIES are classified by the tasks their spec lists.
+SPEC_TASKS = {
+ "gigaam_asr": ["asr"],
+ "maya1": ["tts"],
+ "tone_color_vc": ["vc"],
+ "crisperwhisper": ["asr", "align"],
+ "kugelaudio": ["tts"],
+ "owsm": ["asr"],
+ "owsm_ctc": ["asr"],
+ "sidon": ["s2s"],
+ "smart_turn": ["turn"],
+}
+
+TASK_PAGE = {"tts": "speak", "music": "music", "asr": "transcribe", "sep": "separate"}
+
+CATALOG = Path(__file__).resolve().parents[2] / "frontend/src/features/audio/audio-cpp-catalog.ts"
+
+
[email protected](autouse = True)
+def pinned_runtime(monkeypatch):
+ monkeypatch.setattr(
+ acm, "runtime_knows_family", lambda family: family in AUDIO_CPP_SPEC_FAMILIES
+ )
+
+
[email protected]("folder", sorted(UMBRELLA))
+def test_each_folder_lands_on_its_pages(folder):
+ family, pages = UMBRELLA[folder]
+ spec = {"tasks": SPEC_TASKS[family]} if family in SPEC_TASKS else None
+ policy = acm.family_policy(family, spec, (f"{acm.AUDIO_CPP_REPO}/{folder}", folder), folder)
+ assert list(policy.workflows) == pages
+ # A folder with no page is refused, should it be loaded by id.
+ assert (policy.unsupported is None) == bool(pages)
+
+
+def _catalog() -> tuple[dict[str, list[str]], set[str]]:
+ source = CATALOG.read_text(encoding = "utf-8")
+ seeded = {}
+ for folder, task, workflows in re.findall(
+ r'id: folder\("([^"]+)"\),\s*task: "(\w+)"(?:,\s*workflows: \[([^\]]*)\])?', source
+ ):
+ seeded[folder] = re.findall(r'"(\w+)"', workflows) or [TASK_PAGE[task]]
+ block = re.search(r"AUDIO_CPP_UNOFFERED_FOLDERS[^=]*=\s*\{(.*?)\};", source, re.S).group(1)
+ return seeded, set(re.findall(r'^\s*"([^"]+)":', block, re.M))
+
+
+def test_the_pickers_offer_every_runnable_folder_on_its_pages():
+ seeded, unoffered = _catalog()
+ assert seeded == {folder: pages for folder, (_, pages) in UMBRELLA.items() if pages}
+ assert unoffered == {folder for folder, (_, pages) in UMBRELLA.items() if not pages}
diff --git a/studio/frontend/src/features/audio/audio-cpp-catalog.ts b/studio/frontend/src/features/audio/audio-cpp-catalog.ts
index 3d8c77a8b28..1450a5f1dfe 100644
--- a/studio/frontend/src/features/audio/audio-cpp-catalog.ts
+++ b/studio/frontend/src/features/audio/audio-cpp-catalog.ts
@@ -75,12 +75,38 @@ export const AUDIO_CPP_MODELS: readonly AudioCppModel[] = [
{ id: folder("SeedVC-MLX-GGUF"), task: "tts", workflows: ["convert"] },
{ id: folder("RVC-GGUF"), task: "tts", workflows: ["convert"] },
{ id: folder("MeanVC2-GGUF"), task: "tts", workflows: ["convert"] },
+ { id: folder("Breeze-TTS-2-GGUF"), task: "tts" },
+ { id: folder("DotTTS-MF-GGUF"), task: "tts" },
+ { id: folder("DotTTS-SOAR-GGUF"), task: "tts" },
+ { id: folder("DramaBox-GGUF"), task: "tts" },
+ { id: folder("Higgs-Audio-v3-TTS-4B-GGUF"), task: "tts" },
+ { id: folder("Irodori-TTS-500M-v3-GGUF"), task: "tts" },
+ { id: folder("Irodori-TTS-600M-v3-VoiceDesign-GGUF"), task: "tts" },
+ { id: folder("Irodori-TTS-v4-Small-GGUF"), task: "tts" },
+ { id: folder("MOSS-TTS-Local-v1.5-GGUF"), task: "tts" },
+ { id: folder("MOSS-VoiceGenerator-GGUF"), task: "tts" },
+ { id: folder("MagpieTTS-Multilingual-357M-GGUF"), task: "tts" },
+ { id: folder("Maya1-GGUF"), task: "tts" },
+ { id: folder("NeuTTS-2E-GGUF"), task: "tts" },
+ { id: folder("OmniVoice-GGUF"), task: "tts" },
+ { id: folder("VibeVoice-1.5B-GGUF"), task: "tts" },
+ { id: folder("VoxCPM1-GGUF"), task: "tts" },
+ { id: folder("Fish-Audio-S2-Pro-GGUF"), task: "tts", workflows: ["speak", "clone"] },
+ { id: folder("Confucius4-TTS-GGUF"), task: "tts", workflows: ["clone"] },
+ { id: folder("FireRedTTS3-Base-GGUF"), task: "tts", workflows: ["clone"] },
+ { id: folder("FireRedTTS3-Instruct-GGUF"), task: "tts", workflows: ["clone"] },
+ { id: folder("IndexTTS2.5-GGUF"), task: "tts", workflows: ["clone"] },
+ { id: folder("MioTTS-1.7B-GGUF"), task: "tts", workflows: ["clone"] },
+ { id: folder("Qwen3-TTS-12Hz-1.7B-Base-GGUF"), task: "tts", workflows: ["clone"] },
{ id: "audio-cpp/MiniMax-Music3-GGUF", task: "music" },
{ id: "audio-cpp/Yue2-3B-GGUF", task: "music" },
{ id: folder("ACE-Step1.5-GGUF"), task: "music" },
{ id: folder("Stable-Audio-3-Small-Music-GGUF"), task: "music" },
{ id: folder("Stable-Audio-3-Small-SFX-GGUF"), task: "music" },
{ id: folder("ControlFoley-GGUF"), task: "music" },
+ { id: folder("HeartMuLa-GGUF"), task: "music" },
+ { id: folder("MiDashengLM-Gen-GGUF"), task: "music" },
+ { id: folder("Stable-Audio-3-Medium-GGUF"), task: "music" },
{
id: folder("HTDemucs-GGUF"),
task: "sep",
@@ -113,8 +139,42 @@ export const AUDIO_CPP_MODELS: readonly AudioCppModel[] = [
{ id: folder("Nemotron-3.5-ASR-Streaming-0.6B-GGUF"), task: "asr", languages: ENGLISH },
// Diarizes; Transcribe offers it for the Speakers switch.
{ id: folder("MOSS-Transcribe-Diarize-GGUF"), task: "asr" },
+ { id: folder("Citrinet-ASR-GGUF"), task: "asr" },
+ { id: folder("Cohere-Transcribe-GGUF"), task: "asr" },
+ { id: folder("Fun-ASR-Nano-2512-GGUF"), task: "asr" },
+ { id: folder("GigaAM-ASR-GGUF"), task: "asr" },
+ { id: folder("Granite-Speech-5.0-470M-TurboCTC-GGUF"), task: "asr", languages: ENGLISH },
+ { id: folder("Higgs-Audio-v3-STT-GGUF"), task: "asr" },
+ { id: folder("Hviske-v5.3-GGUF"), task: "asr", languages: ["da"] },
+ { id: folder("Kroko-ASR-GGUF"), task: "asr", languages: ENGLISH },
+ { id: folder("Niagara-ASR-GGUF"), task: "asr", languages: ENGLISH },
+ { id: folder("VibeVoice-ASR-GGUF"), task: "asr" },
+ { id: folder("Voxtral-Mini-4B-Realtime-2602-GGUF"), task: "asr" },
];
+/** Shared-repo folders the pickers leave out, and why; the nightly catalog check fails on an unclassified folder. */
+export const AUDIO_CPP_UNOFFERED_FOLDERS: Readonly<Record<string, string>> = {
+ "CrisperWhisper2.0-GGUF": "needs a newer audio runtime",
+ "KugelAudio-0-Open-GGUF": "needs a newer audio runtime",
+ "OWSM-CTC-GGUF": "needs a newer audio runtime",
+ "OWSM-GGUF": "needs a newer audio runtime",
+ "Sidon-GGUF": "needs a newer audio runtime",
+ "Smart-Turn-v3-GGUF": "needs a newer audio runtime",
+ "MioCodec-25Hz-44.1kHz-v2-GGUF": "the codec MioTTS downloads and loads with",
+ "Qwen3-ForcedAligner-0.6B-GGUF": "the aligner Transcribe uses for Qwen3-ASR timestamps",
+ "MiniMax-H3-Q4-GGUF": "an audio and video package Studio cannot load yet",
+ "Apollo-GGUF": "audio restoration has no page",
+ "AudioSR-GGUF": "audio super-resolution has no page",
+ "UniverSR-GGUF": "audio super-resolution has no page",
+ "PersonaPlex-GGUF": "duplex speech chat has no page",
+ "MMS-Forced-Aligner-GGUF": "forced alignment has no page",
+ "Sortformer-Diar-4spk-v1-GGUF": "speaker diarization has no page",
+ "PulseVAD-GGUF": "voice activity detection has no page",
+ "MuScriptor-Small-GGUF": "music transcription has no page",
+ "Tone-Color-VC-GGUF": "Studio has no conversion request for it yet",
+ "Samsone-GGUF": "describes audio rather than transcribing it",
+};
+
// Families the backend marks speaks=False (audio_cpp_models.FAMILIES), by repo name: Hub rows
// carry no backend workflows before download. Chatterbox-Turbo is its own family and speaks.
const CLONE_ONLY_FAMILY_HINT =
diff --git a/studio/frontend/src/features/model-picker/components/model-selector/model-catalog.check.ts b/studio/frontend/src/features/model-picker/components/model-selector/model-catalog.check.ts
index fd4822dba41..2019b2ccc1f 100644
--- a/studio/frontend/src/features/model-picker/components/model-selector/model-catalog.check.ts
+++ b/studio/frontend/src/features/model-picker/components/model-selector/model-catalog.check.ts
@@ -8,7 +8,13 @@
import assert from "node:assert/strict";
-import { AUDIO_CPP_REPO, isAudioCppFolderId } from "../../../audio/audio-cpp-catalog.ts";
+import {
+ AUDIO_CPP_MODELS,
+ AUDIO_CPP_REPO,
+ AUDIO_CPP_UNOFFERED_FOLDERS,
+ audioCppDisplayName,
+ isAudioCppFolderId,
+} from "../../../audio/audio-cpp-catalog.ts";
import type { CatalogGroup, ModelArtifact } from "./model-catalog.ts";
import {
@@ -1549,6 +1555,31 @@ async function checkCatalogAgainstTheHub(catalogs: CatalogGroup[][]): Promise<st
}
}
+ if (repoId === AUDIO_CPP_REPO) {
+ const folders = new Set(
+ (repo.siblings ?? [])
+ .map((s) => s.rfilename.split("/"))
+ .filter((parts) => parts.length > 1)
+ .map((parts) => parts[0]),
+ );
+ const offered = AUDIO_CPP_MODELS.filter((m) => isAudioCppFolderId(m.id)).map((m) =>
+ audioCppDisplayName(m.id),
+ );
+ const unoffered = Object.keys(AUDIO_CPP_UNOFFERED_FOLDERS);
+ for (const folder of folders) {
+ if (!offered.includes(folder) && !unoffered.includes(folder)) {
+ failures.push(
+ `${repoId}: '${folder}/' is in neither AUDIO_CPP_MODELS nor AUDIO_CPP_UNOFFERED_FOLDERS -- classify it`,
+ );
+ }
+ }
+ for (const folder of unoffered) {
+ if (!folders.has(folder)) {
+ failures.push(`${repoId}: AUDIO_CPP_UNOFFERED_FOLDERS lists '${folder}', which the repo no longer has`);
+ }
+ }
+ }
+
const declaredFiles = [
...new Set(artifacts.map((a) => a.filename).filter((f): f is string => Boolean(f))),
];
@@ -1599,7 +1630,10 @@ async function checkCatalogAgainstTheHub(catalogs: CatalogGroup[][]): Promise<st
if (process.argv.includes("--network")) {
console.log("model-catalog check: --network, asking the Hub about every declared artifact...");
- const failures = await checkCatalogAgainstTheHub([IMAGE_CATALOG, VIDEO_CATALOG]);
+ const audioCppGroups = AUDIO_CATALOG.filter((group) =>
+ group.artifacts.some((artifact) => isAudioCppFolderId(artifact.repoId)),
+ );
+ const failures = await checkCatalogAgainstTheHub([IMAGE_CATALOG, VIDEO_CATALOG, audioCppGroups]);
if (failures.length > 0) {
for (const failure of failures) console.error(`::error::${failure}`);
console.error(`model-catalog network check: ${failures.length} problem(s)`);
diff --git a/studio/frontend/tests/audio-cpp-catalog.test.ts b/studio/frontend/tests/audio-cpp-catalog.test.ts
index 3ac0958b387..1353e28280b 100644
--- a/studio/frontend/tests/audio-cpp-catalog.test.ts
+++ b/studio/frontend/tests/audio-cpp-catalog.test.ts
@@ -16,6 +16,7 @@ import {
AUDIO_CPP_MUSIC_MIN_SECONDS,
AUDIO_CPP_REPO,
AUDIO_CPP_STT_KEYS,
+ AUDIO_CPP_UNOFFERED_FOLDERS,
audioCppDictationModelFor,
audioCppDisplayName,
audioCppModelFor,
@@ -132,6 +133,25 @@ test("recommended ids are unique and name their Hub repo or package folder", ()
assert.equal(audioCppSizeLabel(2358.4 * 1024 * 1024), "2.3 GB");
});
+test("folders of the shared repo the pickers leave out are never seeded and say why", () => {
+ assert.equal(Object.keys(AUDIO_CPP_UNOFFERED_FOLDERS).length, 19);
+ for (const [folder, reason] of Object.entries(AUDIO_CPP_UNOFFERED_FOLDERS)) {
+ assert.equal(audioCppModelFor(`${AUDIO_CPP_REPO}/${folder}`), null, folder);
+ assert.match(folder, /-GGUF$/);
+ assert.ok(reason.trim(), folder);
+ }
+ // Single-language transcription models say so; the rest are multilingual.
+ for (const [folder, languages] of [
+ ["Granite-Speech-5.0-470M-TurboCTC-GGUF", ["en"]],
+ ["Kroko-ASR-GGUF", ["en"]],
+ ["Niagara-ASR-GGUF", ["en"]],
+ ["Hviske-v5.3-GGUF", ["da"]],
+ ["GigaAM-ASR-GGUF", undefined],
+ ] as const) {
+ assert.deepEqual(audioCppModelFor(`${AUDIO_CPP_REPO}/${folder}`)?.languages, languages, folder);
+ }
+});
+
test("recommended models are plain GGUF Audio rows named as on the Hub", () => {
for (const model of AUDIO_CPP_MODELS) {
const group = groupForRepoId(model.id, AUDIO_CATALOG);
diff --git a/studio/frontend/tests/audio-picker-filter.test.ts b/studio/frontend/tests/audio-picker-filter.test.ts
index 56701d59771..6ed3cc62e1b 100644
--- a/studio/frontend/tests/audio-picker-filter.test.ts
+++ b/studio/frontend/tests/audio-picker-filter.test.ts
@@ -14,9 +14,8 @@ const { audioModelsForTask, isMusicGenerationModel } = await import(
"../src/features/audio/catalog.ts"
);
-const { audioCppModelSpeaks } = await import(
- "../src/features/audio/audio-cpp-catalog.ts"
-);
+const { AUDIO_CPP_MODELS, audioCppModelSpeaks, audioCppWorkflowsFor } =
+ await import("../src/features/audio/audio-cpp-catalog.ts");
type Workflow = "speak" | "clone" | "edit" | "convert" | "music" | "transcribe";
const WORKFLOWS: Workflow[] = [
@@ -319,3 +318,30 @@ test("a Fish Audio Hub row lists on both Speak and Clone before download", () =>
assert.equal(audioRowMatchesWorkflow(row, "clone"), true);
assert.equal(audioRowMatchesWorkflow(row, "music"), false);
});
+
+test("every seeded audio GGUF lists on exactly the pages it runs on", () => {
+ const pages = [...WORKFLOWS.slice(0, 5), "separate", "transcribe"] as const;
+ const hubTask = {
+ tts: "text-to-speech",
+ music: "text-to-audio",
+ asr: "automatic-speech-recognition",
+ sep: null,
+ };
+ const listed = (id: string) => {
+ const model = AUDIO_CPP_MODELS.find((entry) => entry.id.endsWith(`/${id}`));
+ assert.ok(model, id);
+ const row = { id: model.id, task: hubTask[model.task] };
+ return pages.filter((page) => audioRowMatchesWorkflow(row, page));
+ };
+ for (const model of AUDIO_CPP_MODELS) {
+ const workflows = audioCppWorkflowsFor(model);
+ assert.deepEqual(listed(model.id.split("/").pop() ?? ""), workflows, model.id);
+ assert.equal(audioCppModelSpeaks(model.id), workflows.includes("speak"), model.id);
+ }
+ assert.deepEqual(listed("Fish-Audio-S2-Pro-GGUF"), ["speak", "clone"]);
+ assert.deepEqual(listed("MioTTS-1.7B-GGUF"), ["clone"]);
+ assert.deepEqual(listed("FireRedTTS3-Instruct-GGUF"), ["clone"]);
+ assert.deepEqual(listed("MOSS-VoiceGenerator-GGUF"), ["speak"]);
+ assert.deepEqual(listed("HeartMuLa-GGUF"), ["music"]);
+ assert.deepEqual(listed("Niagara-ASR-GGUF"), ["transcribe"]);
+});