[Config Refactor] Migrate 5 TTS models (VoxCPM2 / CosyVoice3 / MiMo Audio / Voxtral TTS / Fish Speech S2 Pro) to Pipeline + Deploy schema (#2958)

Signed-off-by: Yueqian Lin <linyueqian@outlook.com>
Co-authored-by: SYLAR <125541396+lishunyang12@users.noreply.github.com>

tests/e2e/offline_inference/test_cosyvoice3.py

@@ -15,19 +15,18 @@ from __future__ import annotations
 import functools
 import io
 import os
-import tempfile
 from pathlib import Path
 from urllib.request import urlopen
 
 import numpy as np
 import pytest
 import soundfile as sf
-import yaml
 from huggingface_hub import snapshot_download
 from vllm.sampling_params import SamplingParams
 
 from tests.helpers.mark import hardware_test
 from tests.helpers.runtime import OmniRunner
+from tests.helpers.stage_config import get_deploy_config_path
 from vllm_omni.model_executor.models.cosyvoice3.config import CosyVoice3Config
 from vllm_omni.model_executor.models.cosyvoice3.tokenizer import get_qwen_tokenizer
 
@@ -44,13 +43,9 @@ REFERENCE_STAGE0_TEMPERATURE = 1.0
 REFERENCE_STAGE0_REPETITION_PENALTY = 2.0
 
 
-def _stage_config(name: str) -> str:
-    return str(Path(__file__).parent.parent.parent.parent / "vllm_omni" / "model_executor" / "stage_configs" / name)
-
-
-STAGE_CONFIGS = [
-    _stage_config("cosyvoice3.yaml"),
-    _stage_config("cosyvoice3_async_chunk.yaml"),
+ASYNC_CHUNK_MODES = [
+    pytest.param(False, id="sync"),
+    pytest.param(True, id="async_chunk"),
 ]
 
 
@@ -138,19 +133,6 @@ def _get_stage_engine_outputs(omni_runner: OmniRunner, stage_id: int):
     raise AttributeError("Unable to locate stage outputs on Omni runner")
 
 
-def _patched_stage_config(base_stage_config: str, model_dir: Path, tmp_dir: Path) -> str:
-    cfg = yaml.safe_load(Path(base_stage_config).read_text(encoding="utf-8"))
-    tokenizer_path = str(model_dir / "CosyVoice-BlankEN")
-    for stage in cfg.get("stage_args", []):
-        engine_args = stage.setdefault("engine_args", {})
-        engine_args["tokenizer"] = tokenizer_path
-        engine_args["enforce_eager"] = True
-        engine_args["hf_overrides"] = {"architectures": ["CosyVoice3Model"]}
-    out_path = tmp_dir / Path(base_stage_config).name
-    out_path.write_text(yaml.safe_dump(cfg, sort_keys=False), encoding="utf-8")
-    return str(out_path)
-
-
 def _build_reference_inputs(prompt_audio: tuple[np.ndarray, int]) -> list[dict[str, object]]:
     return [
         {
@@ -165,54 +147,54 @@ def _build_reference_inputs(prompt_audio: tuple[np.ndarray, int]) -> list[dict[s
 @pytest.mark.core_model
 @pytest.mark.omni
 @hardware_test(res={"cuda": "L4"}, num_cards=1)
-@pytest.mark.parametrize("base_stage_config", STAGE_CONFIGS)
-def test_cosyvoice3_offline_reference_zero_shot(base_stage_config: str) -> None:
+@pytest.mark.parametrize("async_chunk", ASYNC_CHUNK_MODES)
+def test_cosyvoice3_offline_reference_zero_shot(async_chunk: bool) -> None:
     """CosyVoice3 zero-shot reference inference should stop cleanly and produce sane audio."""
     prompt_audio, prompt_sr = _load_reference_prompt_wav()
     model_dir = _resolve_model_dir()
     expected_stop_token = int(CosyVoice3Config().llm["eos_token_id"])
 
-    with tempfile.TemporaryDirectory(prefix="cv3-e2e-") as tmp:
-        stage_config = _patched_stage_config(base_stage_config, model_dir, Path(tmp))
-        with OmniRunner(
-            str(model_dir), seed=42, stage_configs_path=stage_config, stage_init_timeout=300
-        ) as omni_runner:
-            sampling_params_list = omni_runner.get_default_sampling_params_list()
-            sampling_params_list[0] = _reference_zero_shot_stage0_sampling(text=REFERENCE_SYNTH_TEXT)
+    with OmniRunner(
+        str(model_dir),
+        seed=42,
+        stage_configs_path=get_deploy_config_path("cosyvoice3.yaml"),
+        async_chunk=async_chunk,
+        stage_init_timeout=300,
+    ) as omni_runner:
+        sampling_params_list = omni_runner.get_default_sampling_params_list()
+        sampling_params_list[0] = _reference_zero_shot_stage0_sampling(text=REFERENCE_SYNTH_TEXT)
 
-            outputs = omni_runner.omni.generate(
-                _build_reference_inputs((prompt_audio, prompt_sr)), sampling_params_list
+        outputs = omni_runner.omni.generate(_build_reference_inputs((prompt_audio, prompt_sr)), sampling_params_list)
+
+        assert outputs, "No outputs returned"
+        audio_mm = outputs[0].multimodal_output
+        assert "audio" in audio_mm, "No audio output found"
+
+        audio = _concat_audio(audio_mm["audio"])
+        assert audio.size > 0, "Generated audio is empty"
+
+        sr_val = audio_mm.get("sr", 24000)
+        if isinstance(sr_val, list) and sr_val:
+            sr_val = sr_val[-1]
+        if hasattr(sr_val, "item"):
+            sr_val = sr_val.item()
+        sr = int(sr_val)
+        assert sr == 24000, f"Unexpected sample_rate={sr}"
+
+        duration_s = audio.size / sr
+        assert 2.8 <= duration_s <= 8.8, f"Unexpected duration={duration_s:.3f}s (samples={audio.size}, sr={sr})"
+
+        stage0_outputs = _get_stage_engine_outputs(omni_runner, 0)
+        if stage0_outputs:
+            completion = stage0_outputs[0].outputs[0]
+            finish_reason = getattr(completion, "finish_reason", None)
+            stop_reason = getattr(completion, "stop_reason", None)
+            num_tokens = len(getattr(completion, "token_ids", []) or [])
+
+            assert finish_reason == "stop", f"Stage-0 finish_reason={finish_reason}, expected 'stop'"
+            assert int(stop_reason) == expected_stop_token, (
+                f"Stage-0 stop_reason={stop_reason}, expected {expected_stop_token}"
             )
-
-            assert outputs, "No outputs returned"
-            audio_mm = outputs[0].multimodal_output
-            assert "audio" in audio_mm, "No audio output found"
-
-            audio = _concat_audio(audio_mm["audio"])
-            assert audio.size > 0, "Generated audio is empty"
-
-            sr_val = audio_mm.get("sr", 24000)
-            if isinstance(sr_val, list) and sr_val:
-                sr_val = sr_val[-1]
-            if hasattr(sr_val, "item"):
-                sr_val = sr_val.item()
-            sr = int(sr_val)
-            assert sr == 24000, f"Unexpected sample_rate={sr}"
-
-            duration_s = audio.size / sr
-            assert 2.8 <= duration_s <= 8.8, f"Unexpected duration={duration_s:.3f}s (samples={audio.size}, sr={sr})"
-
-            stage0_outputs = _get_stage_engine_outputs(omni_runner, 0)
-            if stage0_outputs:
-                completion = stage0_outputs[0].outputs[0]
-                finish_reason = getattr(completion, "finish_reason", None)
-                stop_reason = getattr(completion, "stop_reason", None)
-                num_tokens = len(getattr(completion, "token_ids", []) or [])
-
-                assert finish_reason == "stop", f"Stage-0 finish_reason={finish_reason}, expected 'stop'"
-                assert int(stop_reason) == expected_stop_token, (
-                    f"Stage-0 stop_reason={stop_reason}, expected {expected_stop_token}"
-                )
-                assert 80 <= num_tokens <= 220, f"Stage-0 num_tokens={num_tokens}, expected sane stop-bound range"
-            else:
-                assert "async_chunk" in Path(base_stage_config).name, "Stage-0 produced no engine outputs"
+            assert 80 <= num_tokens <= 220, f"Stage-0 num_tokens={num_tokens}, expected sane stop-bound range"
+        else:
+            assert async_chunk, "Stage-0 produced no engine outputs"

tests/e2e/offline_inference/test_voxcpm2.py

@@ -7,25 +7,17 @@ import torch
 
 from tests.helpers.mark import hardware_test
 from tests.helpers.runtime import OmniRunner
+from tests.helpers.stage_config import get_deploy_config_path
 
 VOXCPM2_MODEL = "openbmb/VoxCPM2"
-STAGE_CONFIG = os.path.join(
-    os.path.dirname(__file__),
-    "..",
-    "..",
-    "..",
-    "vllm_omni",
-    "model_executor",
-    "stage_configs",
-    "voxcpm2.yaml",
-)
+DEPLOY_CONFIG = get_deploy_config_path("voxcpm2.yaml")
 SAMPLE_RATE = 48000
 
 
 @pytest.fixture(scope="module")
 def voxcpm2_engine():
     """Create VoxCPM2 engine for testing."""
-    with OmniRunner(VOXCPM2_MODEL, stage_configs_path=STAGE_CONFIG) as runner:
+    with OmniRunner(VOXCPM2_MODEL, stage_configs_path=DEPLOY_CONFIG) as runner:
         yield runner.omni
 
 

tests/e2e/offline_inference/test_voxtral_tts.py

@@ -31,13 +31,11 @@ from vllm import SamplingParams
 
 from tests.helpers.mark import hardware_test
 from tests.helpers.runtime import OmniRunner
-from tests.helpers.stage_config import modify_stage_config
+from tests.helpers.stage_config import get_deploy_config_path, modify_stage_config
 from vllm_omni.entrypoints.async_omni import AsyncOmni
 
 MODEL = "mistralai/Voxtral-4B-TTS-2603"
-STAGE_CONFIG = str(
-    Path(__file__).parent.parent.parent.parent / "vllm_omni" / "model_executor" / "stage_configs" / "voxtral_tts.yaml"
-)
+STAGE_CONFIG = get_deploy_config_path("voxtral_tts.yaml")
 SAMPLE_RATE = 24000
 # Minimum expected audio samples for a short sentence (~0.04s of 24kHz audio)
 MIN_AUDIO_SAMPLES = 1000
@@ -66,9 +64,9 @@ def _resolve_stage_config(run_level: str) -> str:
         return modify_stage_config(
             STAGE_CONFIG,
             deletes={
-                "stage_args": {
-                    0: ["engine_args.load_format"],
-                    1: ["engine_args.load_format"],
+                "stages": {
+                    0: ["load_format"],
+                    1: ["load_format"],
                 }
             },
         )

tests/e2e/online_serving/test_cosyvoice3_tts.py

@@ -12,12 +12,11 @@ import os
 os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
 os.environ["VLLM_TEST_CLEAN_GPU_MEMORY"] = "0"
 
-from pathlib import Path
-
 import pytest
 
 from tests.helpers.mark import hardware_test
 from tests.helpers.runtime import OmniServerParams
+from tests.helpers.stage_config import get_deploy_config_path
 
 MODEL = "FunAudioLLM/Fun-CosyVoice3-0.5B-2512"
 
@@ -27,8 +26,8 @@ REF_TEXT = "希望你以后能够做的比我还好呦。"
 
 
 def get_stage_config(name: str = "cosyvoice3.yaml"):
-    """Get the stage config path from vllm_omni model_executor stage_configs."""
-    return str(Path(__file__).parent.parent.parent.parent / "vllm_omni" / "model_executor" / "stage_configs" / name)
+    """Get the deploy config path for CosyVoice3."""
+    return get_deploy_config_path(name)
 
 
 def get_prompt(prompt_type="zh"):
@@ -44,7 +43,7 @@ tts_server_params = [
         OmniServerParams(
             model=MODEL,
             stage_config_path=get_stage_config(),
-            server_args=["--trust-remote-code", "--disable-log-stats"],
+            server_args=["--trust-remote-code", "--disable-log-stats", "--no-async-chunk"],
         ),
         id="cosyvoice3",
     )
@@ -54,7 +53,7 @@ tts_async_chunk_server_params = [
     pytest.param(
         OmniServerParams(
             model=MODEL,
-            stage_config_path=get_stage_config("cosyvoice3_async_chunk.yaml"),
+            stage_config_path=get_stage_config(),
             server_args=["--trust-remote-code", "--disable-log-stats"],
         ),
         id="cosyvoice3_async_chunk",
@@ -93,7 +92,7 @@ def test_voice_clone_zh_001(omni_server, openai_client) -> None:
 def test_voice_clone_zh_002(omni_server, openai_client) -> None:
     """
     Test voice cloning TTS with Chinese text via async_chunk streaming.
-    Deploy Setting: cosyvoice3_async_chunk.yaml
+    Deploy Setting: cosyvoice3.yaml with default ``async_chunk: true``
     Input Modal: text + ref_audio + ref_text
     Output Modal: audio (streamed)
     Input Setting: stream=True

tests/e2e/online_serving/test_mimo_audio.py

@@ -12,7 +12,7 @@ import pytest
 from tests.helpers.mark import hardware_test
 from tests.helpers.media import generate_synthetic_audio
 from tests.helpers.runtime import OmniServerParams, dummy_messages_from_mix_data
-from tests.helpers.stage_config import modify_stage_config
+from tests.helpers.stage_config import get_deploy_config_path
 from vllm_omni.model_executor.model_loader.weight_utils import (
     download_weights_from_hf_specific,
 )
@@ -26,26 +26,6 @@ os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
 models = ["XiaomiMiMo/MiMo-Audio-7B-Instruct"]
 
 
-def get_chunk_config():
-    path = modify_stage_config(
-        str(Path(__file__).parent.parent / "stage_configs" / "mimo_audio_ci.yaml"),
-        updates={
-            "async_chunk": True,
-            "stage_args": {
-                0: {
-                    "engine_args.custom_process_next_stage_input_func": "vllm_omni.model_executor.stage_input_processors.mimo_audio.llm2code2wav_async_chunk"
-                },
-                1: {
-                    "engine_args.max_model_len": 8192,
-                    "engine_args.max_num_batched_tokens": 8192,
-                },
-            },
-        },
-        deletes={"stage_args": {1: ["custom_process_input_func"]}},
-    )
-    return path
-
-
 def download_tokenizer():
     tokenizer_path = os.environ.get("MIMO_AUDIO_TOKENIZER_PATH", MIMO_AUDIO_TOKENIZER_REPO)
     if os.path.exists(tokenizer_path):
@@ -59,19 +39,21 @@ def download_tokenizer():
     return local_path
 
 
-# CI stage config for H100 / MI325
 # Guard module-level setup so test collection doesn't fail in environments
 # where the model cache is read-only or models aren't available.
 try:
-    stage_configs = [get_chunk_config()]
+    stage_configs = [get_deploy_config_path("mimo_audio.yaml")]
     tokenizer_path = download_tokenizer()
     os.environ["MIMO_AUDIO_TOKENIZER_PATH"] = tokenizer_path
 
+    # --load-format dummy applies to every stage pipeline-wide, avoiding a
+    # per-stage yaml rewrite (the old approach wrote a tempfile + atexit-unlink
+    # which raced with CI's process lifecycle).
     test_params = [
         OmniServerParams(
             model=model,
             stage_config_path=stage_config,
-            server_args=["--chat-template", CHAT_TEMPLATE_PATH],
+            server_args=["--chat-template", CHAT_TEMPLATE_PATH, "--load-format", "dummy"],
         )
         for model in models
         for stage_config in stage_configs

tests/e2e/online_serving/test_voxtral_tts.py

@@ -12,19 +12,16 @@ import os
 os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
 os.environ["VLLM_TEST_CLEAN_GPU_MEMORY"] = "0"
 
-from pathlib import Path
-
 import httpx
 import pytest
 
 from tests.helpers.mark import hardware_test
 from tests.helpers.runtime import OmniServerParams
+from tests.helpers.stage_config import get_deploy_config_path
 
 MODEL = "mistralai/Voxtral-4B-TTS-2603"
 
-STAGE_CONFIG = str(
-    Path(__file__).parent.parent.parent.parent / "vllm_omni" / "model_executor" / "stage_configs" / "voxtral_tts.yaml"
-)
+STAGE_CONFIG = get_deploy_config_path("voxtral_tts.yaml")
 EXTRA_ARGS = ["--trust-remote-code", "--enforce-eager", "--disable-log-stats"]
 TEST_PARAMS = [OmniServerParams(model=MODEL, stage_config_path=STAGE_CONFIG, server_args=EXTRA_ARGS)]
 

tests/e2e/stage_configs/mimo_audio_ci.yaml

@@ -1,71 +0,0 @@
-# CI stage config for running MiMo-Audio in multi-stage omni runtime.
-# Based on mimo_audio.yaml with load_format: dummy for CI testing.
-
-async_chunk: false
-stage_args:
-  - stage_id: 0
-    stage_type: llm
-    runtime:
-      process: true
-      devices: "0"
-    engine_args:
-      dtype: bfloat16
-      max_num_seqs: 1
-      model_stage: fused_thinker_talker
-      model_arch: MiMoAudioForConditionalGeneration
-      worker_type: ar
-      scheduler_cls: vllm_omni.core.sched.omni_ar_scheduler.OmniARScheduler
-      tensor_parallel_size: 1
-      gpu_memory_utilization: 0.5
-      enforce_eager: true
-      trust_remote_code: true
-      enable_prefix_caching: false
-      engine_output_type: latent
-      max_model_len: 8192
-      max_num_batched_tokens: 8192
-      load_format: dummy
-    is_comprehension: true
-    final_output: true
-    final_output_type: text
-    default_sampling_params:
-      temperature: 0.6
-      top_p: 0.95
-      top_k: 50
-      max_tokens: 18192
-      seed: 42
-      detokenize: True
-      repetition_penalty: 1.1
-
-  - stage_id: 1
-    stage_type: llm
-    runtime:
-      process: true
-      devices: "0"
-    engine_args:
-      model_stage: code2wav
-      max_num_seqs: 1
-      model_arch: MiMoAudioForConditionalGeneration
-      worker_type: generation
-      scheduler_cls: vllm_omni.core.sched.omni_generation_scheduler.OmniGenerationScheduler
-      tensor_parallel_size: 1
-      gpu_memory_utilization: 0.2
-      enforce_eager: true
-      trust_remote_code: true
-      enable_prefix_caching: false
-      engine_output_type: audio
-      max_model_len: 18192
-      max_num_batched_tokens: 18192
-      async_scheduling: false
-      load_format: dummy
-    engine_input_source: [ 0 ]
-    is_comprehension: false
-    custom_process_input_func: vllm_omni.model_executor.stage_input_processors.mimo_audio.llm2code2wav
-    final_output: true
-    final_output_type: audio
-    default_sampling_params:
-      temperature: 0.0
-      top_p: 1.0
-      top_k: -1
-      max_tokens: 18192
-      seed: 42
-      detokenize: false