[Model] Optimize MiniMax-H3 DLO component lifecycle

Signed-off-by: hsliuustc0106 <liuhongsheng4@huawei.com>
2026-08-25 17:58:08 +08:00
279 changed files with 9367 additions and 17794 deletions
@@ -192,7 +192,7 @@ steps:
      grade: Blocking
      commands:
        - |
-          timeout 45m bash -c '
+          timeout 20m bash -c '
            pytest -s -v tests/e2e/online_serving/test_cosyvoice3_tts_expansion.py -m "slow" --run-level "core_model"
          '

@@ -169,6 +169,7 @@ steps:
          - tests/e2e/online_serving/run_minicpmo_realtime_duplex_soft_interrupt.py
          - vllm_omni/deploy/minicpmo_4_5.yaml
          - tests/e2e/online_serving/helpers/minicpmo_4_5_duplex.py
+          - vllm_omni/deploy/minicpmo_4_5_duplex.yaml
          - vllm_omni/experimental/fullduplex/
          - vllm_omni/model_executor/models/minicpmo_4_5/
          - vllm_omni/model_executor/models/step_audio2/
@@ -83,7 +83,7 @@ steps:
          - export BENCHMARK_DIR=tests/dfx/perf/results
          - |
            set +e
-            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen3_omni_async_chunk.json -m "H100 and full_model"
+            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen3_omni_async_chunk.json
            EXIT=$$?
            buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
            exit $$EXIT
@@ -375,7 +375,7 @@ steps:
      - label: ":full_moon: Diffusion · Quantization Test with L4"
        timeout_in_minutes: 60
        commands:
-          - pip install "vllm-gguf-plugin==0.0.4"
+          - pip install "vllm-gguf-plugin>=0.0.3"
          - pytest -sv tests/diffusion/quantization -m 'full_model and cuda and L4' --run-level "full_model"
        mirror_hardwares: l4_1

@@ -208,6 +208,7 @@ steps:
          - tests/e2e/online_serving/run_minicpmo_realtime_duplex_soft_interrupt.py
          - vllm_omni/deploy/minicpmo_4_5.yaml
          - tests/e2e/online_serving/helpers/minicpmo_4_5_duplex.py
+          - vllm_omni/deploy/minicpmo_4_5_duplex.yaml
          - vllm_omni/experimental/fullduplex/
          - vllm_omni/model_executor/models/minicpmo_4_5/
          - vllm_omni/model_executor/models/step_audio2/
@@ -306,24 +307,6 @@ steps:
            "
        mirror_hardwares: h100_1

-      - label: "Diffusion · MiniMax-H3 DLO DP2 T2VA Test"
-        timeout_in_minutes: 90
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_minimax_h3_dlo_dp2_t2va.py
-          - tests/helpers/assertions.py
-          - tests/helpers/runtime.py
-          - vllm_omni/diffusion/models/minimax_h3/
-          - vllm_omni/diffusion/offloader/
-          - vllm_omni/diffusion/distributed/
-          - vllm_omni/entrypoints/openai/
-        commands:
-          - |
-            timeout 80m bash -c "
-              export VLLM_IMAGE_FETCH_TIMEOUT=60
-              pytest -s -v tests/e2e/online_serving/test_minimax_h3_dlo_dp2_t2va.py -m 'core_model and cuda and diffusion' --run-level 'core_model'
-            "
-        mirror_hardwares: h100_2
-
      - label: "Diffusion · Qwen Image Test"
        source_file_dependencies:
          - tests/e2e/online_serving/test_qwen_image.py
@@ -74,19 +74,6 @@ steps:
            exit $$EXIT
        mirror_hardwares: h100_2

-      - label: ":full_moon: Omni · Perf Test · Async Chunk · Random"
-        key: weekly-omni-performance-async-chunk-random
-        timeout_in_minutes: 180
-        commands:
-          - export BENCHMARK_DIR=tests/dfx/perf/results
-          - |
-            set +e
-            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen3_omni_async_chunk.json -m "H100 and slow"
-            EXIT=$$?
-            buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
-            exit $$EXIT
-        mirror_hardwares: h100_2
-
      - label: ":full_moon: Omni · Perf Test · Multi-Replica"
        key: weekly-omni-performance-multi-replicas
        timeout_in_minutes: 180
@@ -105,7 +105,7 @@ For custom loop structures, follow `vllm_omni/diffusion/models/progress_bar.py`

 ## Path B: Custom/Private Repo Model

-For models without a diffusers pipeline — weights in custom format, model code in a private repo. Real examples: BAGEL, HunyuanImage3. See [references/custom-model-patterns.md](references/custom-model-patterns.md) for concrete custom-model integration patterns.
+For models without a diffusers pipeline — weights in custom format, model code in a private repo. Real examples: DreamID-Omni, BAGEL, HunyuanImage3. See [references/custom-model-patterns.md](references/custom-model-patterns.md) for concrete custom-model integration patterns.

 ### B1. Understand the reference repo

@@ -126,9 +126,9 @@ This is the key design decision for custom models. Follow these placement rules:
 | **Pipeline orchestration** (init, forward, denoise loop) | `vllm_omni/diffusion/models/<name>/pipeline_<name>.py` | Always required |
 | **Custom transformer/backbone** (ported and adapted to vllm-omni) | `vllm_omni/diffusion/models/<name>/<name>_transformer.py` or similar | `wan2_2.py`, `fusion.py`, `bagel_transformer.py` |
 | **Custom sub-models** (VAE, fusion, autoencoder) | `vllm_omni/diffusion/models/<name>/` as separate files | `autoencoder.py`, `fusion.py` |
-| **External dependency code** (original repo utilities) | **External repo**, installed via download script or pip | original-repo package via git clone |
+| **External dependency code** (original repo utilities) | **External repo**, installed via download script or pip | `dreamid_omni` package via git clone |
 | **Hardcoded model configs** | Module-level dicts in pipeline file | `VIDEO_CONFIG`, `AUDIO_CONFIG` dicts |
-| **Download/setup script** | `examples/offline_inference/<name>/download_<name>.py` | `download_<name>.py` |
+| **Download/setup script** | `examples/offline_inference/<name>/download_<name>.py` | `download_dreamid_omni.py` |
 | **Custom `model_index.json`** | Generated by download script, placed at model root | Minimal: `{"_class_name": "YourPipeline", ...}` |

 ### B3. Handle external dependencies
@@ -157,7 +157,7 @@ Copy the essential model files into `vllm_omni/diffusion/models/<name>/` and ada

 Custom models have two common patterns for weight loading:

-**Pattern 1: Bypass standard loader** (eager custom init)
+**Pattern 1: Bypass standard loader** (DreamID-Omni style)

 When the original model has complex custom init functions that load weights in `__init__`:

@@ -16,19 +16,20 @@ vllm_omni/diffusion/models/wan2_2/

 The transformer is loaded separately via `weights_sources` + `load_weights()`. Non-transformer components (VAE, text encoder) are loaded in `__init__` via `from_pretrained()`.

-### Custom model with external deps
+### Custom model with external deps (e.g., DreamID-Omni)

 ```
-vllm_omni/diffusion/models/<name>/
+vllm_omni/diffusion/models/dreamid_omni/
 ├── __init__.py                    # Exports pipeline only
-├── pipeline_<name>.py             # Pipeline: loads ALL weights in __init__ via custom helpers
-└── <backbone>.py                  # Custom transformer / fusion architecture
+├── pipeline_dreamid_omni.py       # Pipeline: loads ALL weights in __init__ via custom helpers
+├── fusion.py                      # Custom fusion architecture (video + audio cross-attention)
+└── wan2_2.py                      # Re-implemented Wan backbone with split API

-examples/offline_inference/<task>/
-└── download_<name>.py             # Downloads weights and/or clones code repo
+examples/offline_inference/x_to_video_audio/
+└── download_dreamid_omni.py       # Downloads weights from 3 HF repos + clones code repo
 ```

-All weights loaded eagerly in `__init__`. `load_weights()` is a no-op. External dependency imported with try/except.
+All weights loaded eagerly in `__init__`. `load_weights()` is a no-op. External dependency (`dreamid_omni` package) imported with try/except.

 ### Custom model with ported code (e.g., BAGEL)

@@ -75,7 +76,7 @@ self.weights_sources = [
 ]
 ```

-### Pattern 3: Fully custom loading
+### Pattern 3: Fully custom loading (DreamID-Omni)

 ```
 init → load ALL weights eagerly via custom helpers → load_weights() = no-op
@@ -107,8 +108,8 @@ Standard diffusers `model_index.json`:
 Custom model `model_index.json` (minimal):
 ```json
 {
-    "_class_name": "YourCustomPipeline",
-    "fusion": "weights/model.safetensors"
+    "_class_name": "DreamIDOmniPipeline",
+    "fusion": "DreamID-Omni/dreamid_omni.safetensors"
 }
 ```

@@ -116,7 +117,7 @@ The only **required** field is `_class_name` — it must match a key in `_DIFFUS

 ## External Dependency Management

-### Git clone + .pth injection
+### Git clone + .pth injection (DreamID-Omni pattern)

 ```python
 def download_dependency():
@@ -162,7 +163,7 @@ The engine checks `isinstance(pipeline, SupportImageInput)` at startup to config

 Diffusers models use `config.json` in each subfolder. Custom models often use:

-**Module-level config dicts**:
+**Module-level config dicts** (DreamID-Omni):
 ```python
 VIDEO_CONFIG = {
    "patch_size": [1, 2, 2], "model_type": "ti2v",
@@ -180,7 +181,7 @@ vae_cfg = bagel_cfg.get("vae_config", {})

 ## Custom Architecture Patterns

-### Split forward API
+### Split forward API (DreamID-Omni)

 When a fusion model needs to interleave blocks from two backbones:

@@ -1,151 +0,0 @@
-"""Benchmark CosyVoice3-style CUDA stream handoff strategies."""
-
-import argparse
-import json
-import statistics
-import time
-
-import torch
-
-from vllm_omni.platforms import current_omni_platform
-
-
-def run_case(
-    *,
-    device: torch.device,
-    steps: int,
-    warmup_steps: int,
-    producer_cycles: int,
-    estimator_cycles: int,
-    use_stream_dependencies: bool,
-) -> dict[str, float | int | str]:
-    caller_stream = torch.cuda.Stream(device=device)
-    estimator_stream = torch.cuda.Stream(device=device)
-    input_tensor = torch.zeros(1024, device=device)
-    output_tensor = torch.empty_like(input_tensor)
-    submission_ms = []
-
-    def step(measure: bool) -> None:
-        with torch.cuda.stream(caller_stream):
-            torch.cuda._sleep(producer_cycles)
-            input_tensor.add_(1)
-
-        start = time.perf_counter_ns()
-        if use_stream_dependencies:
-            estimator_stream.wait_stream(caller_stream)
-        else:
-            caller_stream.synchronize()
-
-        with torch.cuda.stream(estimator_stream):
-            torch.cuda._sleep(estimator_cycles)
-            output_tensor.copy_(input_tensor)
-
-        if use_stream_dependencies:
-            caller_stream.wait_stream(estimator_stream)
-        else:
-            estimator_stream.synchronize()
-
-        if measure:
-            submission_ms.append((time.perf_counter_ns() - start) / 1e6)
-
-    for _ in range(warmup_steps):
-        step(measure=False)
-    caller_stream.synchronize()
-    estimator_stream.synchronize()
-    input_tensor.zero_()
-    torch.accelerator.reset_peak_memory_stats(device)
-    initial_allocated = torch.accelerator.memory_allocated(device)
-
-    start_event = torch.cuda.Event(enable_timing=True)
-    end_event = torch.cuda.Event(enable_timing=True)
-    wall_start = time.perf_counter()
-    with torch.cuda.stream(caller_stream):
-        start_event.record()
-    for _ in range(steps):
-        step(measure=True)
-    with torch.cuda.stream(caller_stream):
-        end_event.record()
-    end_event.synchronize()
-    wall_ms = (time.perf_counter() - wall_start) * 1e3
-    peak_delta_bytes = torch.accelerator.max_memory_allocated(device) - initial_allocated
-
-    expected = torch.full_like(output_tensor, steps)
-    torch.testing.assert_close(output_tensor, expected, rtol=0, atol=0)
-    return {
-        "mode": "wait_stream" if use_stream_dependencies else "synchronize",
-        "steps": steps,
-        "submission_median_ms": statistics.median(submission_ms),
-        "submission_p95_ms": statistics.quantiles(submission_ms, n=20)[18],
-        "submission_mean_ms": statistics.mean(submission_ms),
-        "gpu_elapsed_ms": start_event.elapsed_time(end_event),
-        "wall_elapsed_ms": wall_ms,
-        "peak_allocation_delta_bytes": peak_delta_bytes,
-        "final_value": int(output_tensor[0].item()),
-    }
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--device", default="cuda:0")
-    parser.add_argument("--steps", type=int, default=100)
-    parser.add_argument("--warmup-steps", type=int, default=10)
-    parser.add_argument("--repeats", type=int, default=7)
-    parser.add_argument("--producer-cycles", type=int, default=1_000_000)
-    parser.add_argument("--estimator-cycles", type=int, default=2_000_000)
-    return parser.parse_args()
-
-
-def main() -> None:
-    args = parse_args()
-    device = torch.device(args.device)
-    current_omni_platform.set_device(device)
-    torch.manual_seed(0)
-
-    old_results = []
-    new_results = []
-    for repeat in range(args.repeats):
-        common_args = {
-            "device": device,
-            "steps": args.steps,
-            "warmup_steps": args.warmup_steps,
-            "producer_cycles": args.producer_cycles,
-            "estimator_cycles": args.estimator_cycles,
-        }
-        if repeat % 2 == 0:
-            old_results.append(run_case(**common_args, use_stream_dependencies=False))
-            new_results.append(run_case(**common_args, use_stream_dependencies=True))
-        else:
-            new_results.append(run_case(**common_args, use_stream_dependencies=True))
-            old_results.append(run_case(**common_args, use_stream_dependencies=False))
-
-    old_submission_ms = statistics.median(result["submission_median_ms"] for result in old_results)
-    new_submission_ms = statistics.median(result["submission_median_ms"] for result in new_results)
-    old_gpu_ms = statistics.median(result["gpu_elapsed_ms"] for result in old_results)
-    new_gpu_ms = statistics.median(result["gpu_elapsed_ms"] for result in new_results)
-    print(
-        json.dumps(
-            {
-                "device": torch.cuda.get_device_name(device),
-                "torch": torch.__version__,
-                "cuda": torch.version.cuda,
-                "repeats": args.repeats,
-                "warmup_steps": args.warmup_steps,
-                "producer_cycles": args.producer_cycles,
-                "estimator_cycles": args.estimator_cycles,
-                "old_submission_median_ms": old_submission_ms,
-                "new_submission_median_ms": new_submission_ms,
-                "submission_median_speedup": old_submission_ms / new_submission_ms,
-                "old_gpu_elapsed_median_ms": old_gpu_ms,
-                "new_gpu_elapsed_median_ms": new_gpu_ms,
-                "gpu_elapsed_change_percent": (new_gpu_ms - old_gpu_ms) / old_gpu_ms * 100,
-                "parity": all(result["final_value"] == args.steps for result in old_results + new_results),
-                "old_runs": old_results,
-                "new_runs": new_results,
-            },
-            indent=2,
-        )
-    )
-
-
-if __name__ == "__main__":
-    main()
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project

 # ruff: noqa
 # code borrowed from https://github.com/pytorch/pytorch/blob/main/torch/utils/collect_env.py
@@ -494,16 +494,6 @@ def is_xnnpack_available():


 def get_env_vars():
-    try:
-        from vllm_omni.config.environment_variable_inventory import ENVIRONMENT_VARIABLE_INVENTORY
-    except Exception:
-        # Keep environment collection usable when an incomplete/broken Omni
-        # installation is the reason the user is running this diagnostic.
-        # Importing an Omni submodule executes package initialization, which
-        # may fail with RuntimeError, AssertionError, or OSError as well as
-        # ImportError when vLLM or the accelerator stack is broken.
-        ENVIRONMENT_VARIABLE_INVENTORY = {}
-
    env_vars = ""
    secret_terms = ("secret", "token", "api", "access", "password")
    report_prefix = (
@@ -517,17 +507,12 @@ def get_env_vars():
        "MKL_",
        "NVIDIA",
    )
-    for k, v in sorted(os.environ.items()):
-        omni_classification = ENVIRONMENT_VARIABLE_INVENTORY.get(k)
-        if (omni_classification is not None and omni_classification.redact_value) or any(
-            term in k.lower() for term in secret_terms
-        ):
+    for k, v in os.environ.items():
+        if any(term in k.lower() for term in secret_terms):
            continue
-        if (
-            k in environment_variables
-            or (omni_classification is not None and omni_classification.is_public_omni)
-            or k.startswith(report_prefix)
-        ):
+        if k in environment_variables:
+            env_vars = env_vars + "{}={}".format(k, v) + "\n"
+        if k.startswith(report_prefix):
            env_vars = env_vars + "{}={}".format(k, v) + "\n"

    return env_vars
@@ -1,4 +1,4 @@
-# Target vllm version: v0.28.0 (tag v0.28.0 @ 2cf0a6915ce5).
+# Target vllm version: v0.27.0 (releases/v0.27.0 branch).
 # Keep VLLM_BASE_TAG aligned with the target vLLM release on every rebase.
 #
 # Release-boundary form: there is no precompiled-wheel pin here, because the
@@ -14,14 +14,11 @@
 # core init), registering libnvJitLink.so.13 with ldconfig, and re-pinning numpy
 # under numba's ceiling. All of it was compensation for a base image and a vLLM
 # that disagreed. At a real release boundary they agree, so none of it is
-# needed. The 0.28 rebase repeated the cycle: the v0.28.0rc / final-tag wheels
-# rode on the v0.27.0 base image with the full reinstall block until the
-# official v0.28.0 image shipped, at which point this file dropped back to the
-# form you are reading. If you pin an untagged commit again, restore the
-# reinstall block — agent/tasks/20_update_wheel_url.sh fails the run rather
-# than letting the Dockerfile silently ship the wrong vLLM.
+# needed. If you pin an untagged commit again, restore the reinstall block —
+# agent/tasks/20_update_wheel_url.sh fails the run rather than letting the
+# Dockerfile silently ship the wrong vLLM.
 ARG VLLM_BASE_IMAGE=vllm/vllm-openai
-ARG VLLM_BASE_TAG=v0.28.0
+ARG VLLM_BASE_TAG=v0.27.0

 # We use registry-based layer caching for the dependencies,
 # where the tag is determined based on the hash of the contents
@@ -1,4 +1,4 @@
-ARG BASE_IMAGE=vllm/vllm-openai:v0.28.0
+ARG BASE_IMAGE=vllm/vllm-openai:v0.26.0
 FROM ${BASE_IMAGE}

 ARG COMMON_WORKDIR=/app
@@ -1,4 +1,4 @@
-ARG BASE_IMAGE=vllm/vllm-openai-rocm:v0.28.0
+ARG BASE_IMAGE=vllm/vllm-openai-rocm:v0.27.0
 FROM ${BASE_IMAGE} AS base

 # Declare a variable to know if we want to use the nightly build or the stable build.
@@ -10,7 +10,7 @@ FROM ${BASE_IMAGE} AS base
 #    we should swap over to use stable release ASAP.
 #    We should avoid relying on custom commits.
 ARG USE_NIGHTLY_BUILD=0
-ARG VLLM_VERSION_OR_COMMIT_HASH=v0.28.0
+ARG VLLM_VERSION_OR_COMMIT_HASH=v0.27.0
 ARG ARG_PYTORCH_ROCM_ARCH
 ENV PYTORCH_ROCM_ARCH=${ARG_PYTORCH_ROCM_ARCH:-${PYTORCH_ROCM_ARCH}}

@@ -24,6 +24,7 @@ nav:
      - Text-To-Speech: user_guide/examples/offline_inference/text_to_speech.md
      - Text-To-Video: user_guide/examples/offline_inference/text_to_video.md
      - X-To-Text: user_guide/examples/offline_inference/x_to_text.md
+      - X-To-Video-Audio: user_guide/examples/offline_inference/x_to_video_audio.md
    - Online Serving:
      - Image-To-Image: user_guide/examples/online_serving/image_to_image.md
      - Image-To-Video: user_guide/examples/online_serving/image_to_video.md
@@ -53,7 +54,6 @@ nav:
      - BitsAndBytes W4: user_guide/quantization/bitsandbytes.md
      - MXFP8 W8A8: user_guide/quantization/mxfp8.md
      - MXFP4 W4A4: user_guide/quantization/mxfp4.md
-      - SVDQuant W4A4: user_guide/quantization/svdquant.md
      - ModelOpt: user_guide/quantization/modelopt.md
      - AutoRound: user_guide/quantization/autoround.md
      - msModelSlim: user_guide/quantization/msmodelslim.md
@@ -2,11 +2,6 @@

 The CLI for vLLM-Omni inherits from vllm with some additional arguments.

-Environment variables are process configuration rather than CLI-only options.
-See the [Environment Variables](../configuration/environment_variables.md)
-reference for ownership, precedence, evaluation time, and per-stage `env`
-scoping.
-
 ## serve

 Starts the vLLM-Omni OpenAI Compatible API server.
@@ -44,5 +39,4 @@ vllm bench serve --omni \
    --num-prompts  5
 ```

-See [vllm bench serve](./bench/serve.md) for serving benchmark arguments and
-dataset-specific examples, including OmniInteract native-duplex sessions.
+See [vllm bench serve](./bench/serve.md) for the full reference of all available arguments.
@@ -2,7 +2,7 @@
 The vllm bench command launches the vLLM-Omni benchmark to evaluate the performance of multimodal models.

 ## Notes
-vLLM-Omni registers the `openai-chat-omni`, `openai-audio-speech`, `openai-image-edits-omni`, `daily-omni`, and `openai-realtime-duplex` serving benchmark backends. It also adds the `omniinteract` dataset.
+vLLM-Omni registers the `openai-chat-omni`, `openai-audio-speech`, `openai-image-edits-omni`, and `daily-omni` serving benchmark backends.

 ## Basic Parameter Description
 You can use `vllm bench serve --omni --help=all` to get descriptions of all parameters. The commonly used parameters are described below:
@@ -10,7 +10,7 @@ You can use `vllm bench serve --omni --help=all` to get descriptions of all para
  Enable Omni (multimodal) mode, supporting multimodal inputs and outputs such as images, videos, and audio.

 - `--backend`
-  Specify the backend adapter. vLLM-Omni adds `openai-chat-omni`, `openai-audio-speech`, `openai-image-edits-omni`, `daily-omni`, and `openai-realtime-duplex` to the upstream vLLM backend choices.
+  Specify the backend adapter. vLLM-Omni adds `openai-chat-omni`, `openai-audio-speech`, `openai-image-edits-omni`, and `daily-omni` to the upstream vLLM backend choices.

 - `--model`
  The model identifier to load, filled according to the models supported by vLLM-Omni.
@@ -19,7 +19,7 @@ You can use `vllm bench serve --omni --help=all` to get descriptions of all para
  The API endpoint exposed externally, to which clients send their requests.

 - `--dataset-name`
-  The name of the dataset used; random-mm indicates generating random multimodal inputs (images, videos, audio), while `omniinteract` replays official OmniInteract videos.
+  The name of the dataset used; random-mm indicates generating random multimodal inputs (images, videos, audio).

 - `--num-prompts`
  The total number of requests to send, an integer.
@@ -269,44 +269,6 @@ We use audio generation time / audio duration to calculate RTF.

 </details>

-### OmniInteract Realtime Benchmark
-
-OmniInteract runs each video as one native-duplex WebSocket sample in the standard serving-benchmark lifecycle:
-
-```bash
-vllm bench serve --omni \
-  --backend openai-realtime-duplex \
-  --dataset-name omniinteract \
-  --dataset-path /path/to/OmniInteract \
-  --model openbmb/MiniCPM-o-4_5 \
-  --base-url http://127.0.0.1:8000 \
-  --endpoint /v1/realtime \
-  --omniinteract-ref-audio /path/to/reference.wav \
-  --omniinteract-output-dir ./omniinteract-artifacts \
-  --num-prompts 3 \
-  --num-warmups 0
-```
-
-`--dataset-path` accepts an extracted directory, `data.tar[.gz]`, or a Hugging Face dataset ID; omitting it uses
-`lucky-lance/OmniInteract`. `--num-prompts` is the total across subsets and defaults to 3 for OmniInteract; explicit `0`
-selects all and oversize values use all available cases. Reference audio is required, and OmniInteract uses the
-`/v1/realtime` endpoint.
-
-Audio is replayed as 16 kHz PCM16 in 200 ms chunks and video at 1 FPS with real-time pacing. All selected media is decoded
-before timing and remains in client memory for the run, so `--max-concurrency` does not limit media preparation memory; use
-explicit `--num-prompts 0` only when the client has enough RAM for the full dataset. Media commands are bounded by
-`--omniinteract-media-timeout-s`, and concurrency defaults to 1. Standard request-rate, warmup, result-saving, and summary
-options apply. Use `--omniinteract-require-response` only for functional E2E cases; LISTEN is a valid benchmark result.
-
-Each completed case writes `output.wav`, `wav_transcript.json`, `events.json`, `result.json`, and a final `.done` marker under
-`--omniinteract-output-dir`. The root also contains `batch_summary.json` and `official_eval_manifest.jsonl`; failed cases write
-`.failed.json`. Runs sharing one output root are serialized. Completion validates transport, response lifecycle, and artifacts,
-not answer accuracy. Transcript timestamps are serialized playback-queue times. Clipped or cancelled outputs are ineligible and
-omitted from the official manifest; `audio_clipped_bytes` records output beyond the rounded video horizon.
-
-TTFT, TTFP, and RTF start at client receipt of `response.created`. TPOT/ITL use engine stage-0 timing; ITL is emitted only when
-every token interval is present.
-
 ### Multi-Modal Benchmark

 <details class="admonition abstract" markdown="1">
@@ -7,9 +7,6 @@ For options within a vLLM Engine, please refer to the [vLLM 0.26 configuration g
 Each model defines fixed topology in a registered `PipelineConfig` and runtime
 overrides in a deploy YAML.

-For process-level settings shared by the CLI, deploy YAML, workers, and model
-integrations, see [Environment Variables](./environment_variables.md).
-
 For a specific example, see the [Qwen2.5-Omni deploy config](gh-file:vllm_omni/deploy/qwen2_5_omni.yaml). The matching frozen pipeline topology lives at [vllm_omni/model_executor/models/qwen2_5_omni/pipeline.py](gh-file:vllm_omni/model_executor/models/qwen2_5_omni/pipeline.py).

 For an introduction, see [Pipeline and deploy configurations](./stage_configs.md).
@@ -1,238 +0,0 @@
-# Environment Variables
-
-Environment variables are process-level configuration shared by the CLI,
-deploy YAML, Python APIs, worker processes, and model integrations. They are
-therefore documented under **User Guide → Configuration**, rather than under
-CLI Reference.
-
-This page describes the public vLLM-Omni environment-variable contract on the
-`latest` documentation branch. Use the documentation for your installed
-vLLM-Omni release when behavior differs.
-
-!!! important "Public contract"
-    Only names in [Public vLLM-Omni variables](#public-vllm-omni-variables) are
-    public Omni configuration. A name found in source code is not automatically
-    supported: model-specific, benchmark, platform, and internal variables have
-    separate ownership and lifecycle rules.
-
-## Naming and implementation boundary
-
-New public variables owned by vLLM-Omni must use the `VLLM_OMNI_` prefix.
-Existing public names with older prefixes remain supported for compatibility,
-but they do not establish naming precedent for new settings. Inherited vLLM
-and third-party names retain the prefix chosen by their owning project.
-
-The source [environment-variable inventory](gh-file:vllm_omni/config/environment_variable_inventory.py)
-records ownership, migration disposition, and redaction metadata. Unlike
-`vllm.envs`, it is not an executable value resolver: existing consumers still
-own parsing, defaults, precedence, and evaluation time. The public tables below
-describe those live consumer contracts. Stable model or stage behavior should
-move to typed configuration, and request-varying behavior should move to a
-request schema instead of adding another environment variable.
-
-## Precedence and evaluation time
-
-There is no repository-wide rule that makes environment variables override (or
-lose to) every CLI, YAML, or request option. The tables below state precedence
-for each public setting. In general:
-
- request fields should control behavior that can vary per request;
- typed deploy or stage configuration should control stable model and stage
-  behavior;
- environment variables are appropriate for process launch, platform
-  integration, emergency diagnostics, and compatibility fallbacks.
-
-An environment variable can be read while a module is imported, when server or
-model configuration is constructed, when a worker is spawned, or whenever a
-property is accessed. Set import- and startup-time variables before invoking
-`vllm serve` or importing vLLM-Omni. Changing the parent shell after workers
-start does not update existing worker environments.
-
-The lifecycle labels used below are:
-
- **Stable** — reviewed public configuration; changes require compatibility
-  consideration.
- **Experimental** — public for evaluation, but its contract may still evolve.
- **Diagnostic** — supported for investigation or temporary mitigation, not as
-  a normal tuning interface.
- **Deprecated** — compatibility alias; migrate to the named replacement.
-
-## Public vLLM-Omni variables
-
-### Diffusion backend and cache selection
-
-| Name | Type and default | Applies to and read time | Precedence and invalid values | Lifecycle |
-| --- | --- | --- | --- | --- |
-| `DIFFUSION_ATTENTION_BACKEND` | Backend name or `auto`; default `auto` (platform selection) | Diffusion stages; read when `OmniDiffusionConfig` is constructed | `diffusion_attention_config.default` wins. An unknown backend fails during backend resolution. | Stable fallback |
-| `DIFFUSION_CACHE_BACKEND` | `none`, `cache_dit`, `tea_cache`, `mag_cache`, `step_cache`, `stepcache`, or `step_cache_dit`; default `none` | Diffusion runner startup | Explicit `cache_backend` in config wins. Otherwise this name wins over the deprecated alias. Unsupported values raise `ValueError` during runner setup. | Stable fallback |
-| `DIFFUSION_CACHE_ADAPTER` | Same values as `DIFFUSION_CACHE_BACKEND`; default `none` | Diffusion runner startup | Used only when neither explicit `cache_backend` nor `DIFFUSION_CACHE_BACKEND` is set. Unsupported values raise `ValueError`. | Deprecated; use `DIFFUSION_CACHE_BACKEND` |
-| `OMNI_DIFFUSION_PROMPT_EMBED_CACHE` | Boolean: `1`, `true`, `yes`, `on`, `0`, `false`, `no`, or `off`; default disabled | Each diffusion runner; resolved during model setup | A recognized environment value overrides the explicit enable setting. An unrecognized value is ignored. | Experimental |
-| `OMNI_DIFFUSION_PROMPT_EMBED_CACHE_SIZE` | Positive integer; default `32` entries | Each diffusion runner; resolved during model setup | A valid environment value overrides the explicit cache size. A non-integer logs a warning; a non-positive value is ignored. | Experimental |
-| `OMNI_DIFFUSION_SESSION_STATE_MANAGER` | Boolean with the same accepted spellings as the prompt cache; default disabled | Experimental diffusion session manager; model setup | A recognized environment value overrides the explicit enable setting. An unrecognized value is ignored. | Experimental |
-| `OMNI_DIFFUSION_SESSION_STATE_MANAGER_MAX_SESSIONS` | Positive integer; default `64` | Experimental diffusion session manager; model setup | A valid environment value overrides the explicit maximum. A non-integer logs a warning; a non-positive value is ignored. | Experimental |
-
-Backend names for `DIFFUSION_ATTENTION_BACKEND` are the members of
-`DiffusionAttentionBackendEnum`, such as `FLASH_ATTN`, `TORCH_SDPA`,
-`SAGE_ATTN`, `FLASHINFER_ATTN`, and `TRTLLM_ATTN`. Platform support still
-depends on the installed kernels and model path.
-
-### Serving and runtime
-
-| Name | Type and default | Applies to and read time | Precedence and invalid values | Lifecycle |
-| --- | --- | --- | --- | --- |
-| `SPEAKER_SAMPLES_DIR` | Filesystem path; default `~/.cache/vllm-omni/speakers` | Speech server; read when speaker storage initializes | Environment-only setting. The directory is created; filesystem errors propagate. | Stable |
-| `SPEAKER_MAX_UPLOADED` | Integer; default `1000` | Speech server; read when speaker storage initializes | Environment-only setting. A non-integer logs a warning and uses `1000`; range is not otherwise validated. | Stable |
-| `VLLM_OMNI_ASYNC_OUTPUT_TIMEOUT` | Float seconds; default `600` | Diffusion engine async-output wait in `step_streaming`; resolved per call on the request path, not at import | Environment-only setting. A non-float or `<=0` value warns once and uses the default. | Experimental |
-| `VLLM_OMNI_EVENT_DRIVEN_ORCH` | `1`, `true`, `yes` or `on` enables; default `0` (off) | Orchestration loop and the serving-side final-output drain; read once when the `Orchestrator` is constructed | Environment-only setting. Values are stripped and case-normalized; any unrecognized value leaves the legacy poll loop selected. | Experimental |
-| `VLLM_OMNI_INPUT_WAIT_TIMEOUT_S` | Float seconds; default `600`; `<=0` disables | Full-payload input coordinator, not async-chunk transfer; read when the scheduler module imports in each worker | Environment-only setting. A non-float logs a warning and uses `600`. | Stable operational control |
-| `VLLM_OMNI_ORCH_MONITOR_PATH` | Filesystem path; default `<current-working-directory>/vllm_omni_orch_monitor_<timestamp>.json` | Orchestrator monitor enabled by `--enable-orch-monitor`; read when the monitor is created | Environment-only path override. Parent directories are created; write errors are logged. | Diagnostic |
-| `VLLM_OMNI_VIDEO_SYNC_TIMEOUT` | Float seconds; default `600` | Synchronous Videos API; read when the API server module imports | Environment-only setting. A non-float raises `ValueError` during import. | Experimental |
-| `VLLM_VIDEO_ASYNC_CHUNK` | `on` or `off`; default `on` | Streaming video output; read on attribute access | Environment-only setting. Values are trimmed and case-normalized; an invalid value warns once and uses `on`. | Experimental |
-| `VLLM_VIDEO_AUDIO_DELTA_MODE` | `fast` or `slow`; default `fast` | Streaming video audio deltas; read on attribute access | Environment-only setting. Values are trimmed and case-normalized; an invalid value warns once and uses `fast`. | Experimental |
-
-### Server storage
-
-Storage names use Pydantic's nested-settings delimiter (`__`). They are read
-when `ServerSettings` is initialized, normally during server import/startup.
-Invalid integer values raise a Pydantic validation error.
-
-| Name | Type and default | Meaning | Lifecycle |
-| --- | --- | --- | --- |
-| `VLLM_OMNI_SERVER_STORAGE__PATH` | Path; default `/tmp/storage` | Directory for completed server files. | Stable |
-| `VLLM_OMNI_SERVER_STORAGE__FILE_CONCURRENCY` | Integer; default `4` | Maximum concurrent file operations. No additional range validation is currently applied. | Stable |
-| `VLLM_OMNI_SERVER_STORAGE__FILE_TTL` | Integer seconds or unset; default unset | Optional lifetime for locally stored files. | Stable |
-| `VLLM_OMNI_SERVER_STORAGE__TTL_SWEEP_INTERVAL` | Integer seconds or unset | Sweep frequency. If file TTL is set and this is unset, the effective default is `300`. | Stable |
-| `VLLM_OMNI_STORAGE_PATH` | Path | Deprecated alias for `VLLM_OMNI_SERVER_STORAGE__PATH`. The new name wins when both are set. | Deprecated |
-| `VLLM_OMNI_STORAGE_MAX_CONCURRENCY` | Integer | Deprecated alias for `VLLM_OMNI_SERVER_STORAGE__FILE_CONCURRENCY`. The new name wins when both are set. | Deprecated |
-
-The deprecated aliases emit `DeprecationWarning`. They do not affect file TTL
-settings.
-
-### Quantization diagnostics and performance
-
-| Name | Type and default | Applies to and read time | Precedence and invalid values | Lifecycle |
-| --- | --- | --- | --- | --- |
-| `VLLM_OMNI_SKIP_NVFP4_NAN_CLAMP` | Boolean truthy spellings: `1`, `true`, `yes`, `on`; default false | ModelOpt NVFP4 compatibility patch; read when `vllm_omni.patch` imports | Environment-only escape hatch. Any other value means false. Set only to diagnose the upstream NaN-scale issue. | Diagnostic and temporary |
-| `VLLM_OMNI_USE_QUACK_FP8` | Boolean truthy spellings: `1`, `true`, `yes`, `on`; unset means hardware auto-detection | FP8 scaled matrix multiplication; evaluated when quack capability is selected | A set value overrides auto-detection. Any non-truthy value forces quack off. If quack cannot load, vLLM-Omni warns and falls back to FlashInfer. | Experimental performance control |
-
-`QUACK_CACHE_DIR` is owned by the external quack library and is not an
-Omni-owned variable, even though vLLM-Omni supplies a persistent default when
-it is unset.
-
-## Per-stage environment
-
-Deploy configurations can set arbitrary environment keys for one stage:
-
-```yaml
-stages:
-  - stage_id: 0
-    env:
-      HCCL_IF_BASE_PORT: 23000
-      MY_MODEL_CACHE: /mnt/model-cache
-```
-
-The legacy nested form under `runtime.env` is also accepted. vLLM-Omni converts
-keys and values to strings, applies them while the stage engine or child process
-is launched, logs keys but not values, and restores the parent process's prior
-environment afterward. A child process inherits the scoped values. This keeps
-sibling stages from permanently changing one another's parent environment.
-
-This scoping has two consequences:
-
-1. A setting read inside stage/model initialization can see the stage value.
-2. A setting already cached by an import that occurred before stage launch
-   cannot be changed retroactively with stage `env`.
-
-Stage `env` is an escape hatch for process and third-party settings, not a
-replacement for typed stage configuration. Do not put request-varying behavior
-there. Secret values may reach child processes; logs and diagnostics must emit
-their keys only.
-
-## Inherited vLLM variables
-
-vLLM-Omni also reads variables through its aligned vLLM dependency. Refer to
-the [vLLM 0.26 environment-variable reference](https://docs.vllm.ai/en/v0.26.0/configuration/env_vars.html)
-for their definitions. This includes vLLM launch, cache, logging, plugin, ROCm,
-XPU, ModelScope, and FlashInfer workspace settings.
-
-An inherited name does not become Omni-owned because Omni reads or forwards it.
-Where behavior differs, the Omni-specific page should document only that
-difference. For example, device-visibility values can be further narrowed by a
-stage's `devices` setting.
-
-## Platform, external, and secret variables
-
-Hardware runtimes, distributed launchers, and third-party libraries retain
-ownership of their variables. Common groups include:
-
- device visibility (`ASCEND_RT_VISIBLE_DEVICES`, `HIP_VISIBLE_DEVICES`, and
-  `MUSA_VISIBLE_DEVICES`);
- distributed launch (`MASTER_ADDR`, `MASTER_PORT`, `RANK`, and `WORLD_SIZE`);
- Hugging Face cache and authentication (`HF_HOME`, `HF_TOKEN`, and related
-  names);
- accelerator libraries such as NCCL, FlashInfer, MindIE, MORI, and quack.
-
-Consult the owning project's documentation for accepted values and support.
-`HF_TOKEN`, `HUGGINGFACE_HUB_TOKEN`, and `OPENAI_API_KEY` are explicitly marked
-for redaction in the reviewed inventory. Never print their values in environment
-collection, examples, bug reports, or logs.
-
-## Model-specific variables
-
-The audit found 56 variables read by a single model or pipeline family. They are
-not listed as public usage options here because doing so would turn implementation
-escape hatches into an accidental compatibility contract.
-
-Every audited model-specific name has a migration disposition in the
-[environment-variable inventory](gh-file:vllm_omni/config/environment_variable_inventory.py):
-
-| Disposition | Count | Required outcome |
-| --- | ---: | --- |
-| Promote | 33 | Move a stable setting into typed stage or model configuration. |
-| Request scope | 6 | Move request-varying behavior into a declared request-option schema. |
-| External | 0 | Retain only when a supported third-party library owns the contract. |
-| Internalize | 11 | Keep a debug or diagnostic switch out of public documentation and configuration. |
-| Deprecate/remove | 6 | Remove a compatibility escape hatch that has no continuing contract. |
-
-The disposition is a migration target, not a statement that the existing
-environment switch is stable. Promote or request-scope work should land in
-model-owner-reviewed follow-up changes with validation and model-page updates.
-The family-sized migration packages and their ownership gate are tracked in
-[#6232](https://github.com/vllm-project/vllm-omni/issues/6232).
-
-## Environment collection and troubleshooting
-
-Run the repository collector when preparing a bug report:
-
-```bash
-python collect_env.py
-```
-
-The environment section includes the safe public Omni allowlist, registered
-vLLM variables, and selected platform prefixes. It omits names marked for
-redaction and names containing common secret terms. Review the output before
-sharing it. A key supplied through stage `env` is not collected merely because
-it appears in deploy configuration; the same allowlist and prefix rules apply.
-
-If a setting appears ineffective, first check its read time in the tables
-above. Restart processes after changing import- or startup-time values, verify
-that the variable reaches the intended worker, and check whether an explicit
-typed configuration field takes precedence.
-
-## Benchmark and internal variables
-
-The reviewed inventory marks 20 benchmark variables as transitional while
-benchmark configuration moves to CLI/request schemas in
-[issue #5376](https://github.com/vllm-project/vllm-omni/issues/5376). They are not
-part of the serving/runtime contract.
-
-Internal process-coordination and debug variables are deliberately excluded
-from this page. The CI scanner resolves string literals and module-level string
-constants used by direct `os` access, local wrapper helpers, aliased `os`
-imports, and environment membership checks. Server-storage names generated by
-Pydantic settings are checked separately against their model fields.
-
-Names assembled from cross-module metadata and arbitrary keys supplied through
-stage `env` cannot be inferred reliably. Contributors must classify those names
-explicitly. CI fails when a statically resolved name has no classification or
-when a reviewed public name is absent from this page.
@@ -14,7 +14,7 @@ describe fixed model topology and are not accepted in deploy YAMLs.
 Common `PipelineConfig` fields include:

 | Field | Description |
-| ------- | ------------- |
+|-------|-------------|
 | `model_type` | Pipeline identifier used during model and config resolution. |
 | `default_deploy_config_name` | Bundled deploy YAML loaded when the user does not pass `deploy_config`. |
 | `model_arch` | Default Hugging Face architecture for the pipeline. |
@@ -26,7 +26,7 @@ Common `PipelineConfig` fields include:
 Common `StagePipelineConfig` fields include:

 | Field | Description |
-| ------- | ------------- |
+|-------|-------------|
 | `stage_id` | Stable stage identifier. |
 | `model_stage` | Logical stage name used by runtime and strategy resolution. |
 | `execution_type` | `LLM_AR`, `LLM_GENERATION`, or `DIFFUSION`. |
@@ -49,10 +49,10 @@ deployment overrides.
 The new deploy schema lives under `vllm_omni/deploy/` and is paired with a frozen `PipelineConfig` registered by the model's `pipeline.py`. Each deploy YAML has these top-level fields:

 | Field | Type | Required | Default | Description |
-| ------- | ------ | ---------- | --------- | ------------- |
+|-------|------|----------|---------|-------------|
 | `base_config` | str (path) | optional | — | Overlay parent (relative or absolute). `stages:` / `platforms:` deep-merged by stage_id; other scalars overlay-wins. Intended for user-authored overlays; prod yamls stay flat. |
 | `async_chunk` | bool | optional | `true` | Enable chunked streaming between stages. Pin to `false` if the pipeline runs end-to-end. |
-| `session_mode` | str | optional | `"turn"` | Session behavior. MiniCPM-o 4.5 deploy YAMLs set `"duplex"` so `/v1/realtime` and chat share the same profile. |
+| `session_mode` | str | optional | `"turn"` | Session behavior. Use `"duplex"` only with a pipeline that enables duplex control. |
 | `active_stream_window` | int | optional | `0` | Number of active downstream stream slots; `0` preserves all-stream cycling. |
 | `duplex_session` | dict | optional | runtime defaults | Full-duplex session lifecycle, buffering, replay, and capacity limits. |
 | `connectors` | dict | optional | `null` | Named connector specs (`{name, extra}`). Referenced by each stage's `input_connectors` / `output_connectors`. See [Connector schema](#connector-schema). |
@@ -84,7 +84,7 @@ subprocess on one GPU. `ray` / `external_launcher` are not fully supported yet.
 Each entry under `stages:` accepts any `StageDeployConfig` field directly (no nested `engine_args:`). Only fields whose value legitimately varies across stages live here; pipeline-wide settings (trust_remote_code, distributed_executor_backend, dtype, quantization, prefix/chunked prefill, DP/PP sizes) are declared at the top level and applied to every stage. Unknown keys fall through to `engine_extras:` and are forwarded to the engine. Frequently used fields are listed below; the source-of-truth schema is `StageDeployConfig` in `vllm_omni/config/stage_config.py`.

 | Field | Type | Required | Default | Description |
-| ------- | ------ | ---------- | --------- | ------------- |
+|-------|------|----------|---------|-------------|
 | `stage_id` | int | required | — | Stage identity; matched against `PipelineConfig.stages[*].stage_id`. |
 | `max_num_seqs` | int \| null | optional | `null` | Max concurrent sequences per stage. |
 | `gpu_memory_utilization` | float \| null | optional | `null` | Per-stage total memory target; used for automatic KV-cache sizing. |
@@ -94,14 +94,12 @@ Each entry under `stages:` accepts any `StageDeployConfig` field directly (no ne
 | `max_num_batched_tokens` | int \| null | optional | `null` | Per-stage prefill/token budget; also contributes to the native maximum in-flight token limit. |
 | `max_model_len` | int \| null | optional | `null` | Per-sequence context or KV length; `-1` enables native cache-capacity auto-fitting, while values above the HF default auto-set `VLLM_ALLOW_LONG_MAX_MODEL_LEN=1`. |
 | `async_scheduling` | bool \| null | optional | `null` | Per-stage async scheduling toggle. |
-| `devices` | str \| null | optional | `null` | Device list assigned to this stage. The number of device ids must equal this stage's local world size (`tensor_parallel_size` × local data-parallel size × `pipeline_parallel_size`, or `num_replicas` × that product for a replica pool); a mismatch fails early — see the note below. |
+| `devices` | str \| null | optional | `null` | Device list assigned to this stage. |
 | `output_connectors` | dict \| null | optional | `null` | Keyed by `to_stage_<n>`; values are names registered under top-level `connectors:`. |
 | `input_connectors` | dict \| null | optional | `null` | Keyed by `from_stage_<n>`; values are names registered under top-level `connectors:`. |
 | `default_sampling_params` | dict \| null | optional | `null` | Baseline sampling params. Deep-merged with pipeline `sampling_constraints` (pipeline wins). |
 | `engine_extras` | dict | optional | `{}` | Catch-all for engine fields not listed above; deep-merged across overlays and forwarded to the stage engine. |

-**Note:** a stage's `devices` count must equal its local world size (`tensor_parallel_size` × `data_parallel_size_local` × `pipeline_parallel_size`, falling back to global `data_parallel_size` when the local size is unset), or `num_replicas` × that product for a replica pool. A mismatch fails early and names the offending stage. A top-level `--tensor-parallel-size` is broadcast to every stage, so it can make a single-GPU stage violate this contract ([issue #5003](gh-issue:5003)); fix that case with `--stage-overrides` (set `tensor_parallel_size` and `devices` together per stage) or set TP only on the multi-GPU stage.
-
 ### Connector schema

 Each entry under top-level `connectors:` follows this shape:
@@ -115,9 +113,9 @@ connectors:
      # Additional connector-specific options
 ```

-| Connector class          | Use case                                                              | `extra` keys                                                                                                      |
-|--------------------------|-----------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------|
-| `SharedMemoryConnector`  | Same-host KV transfer between stages (default for bundled YAMLs).     | None. All payloads use shared memory.                                                                             |
+| Connector class | Use case | `extra` keys |
+|-----------------|----------|--------------|
+| `SharedMemoryConnector` | Same-host KV transfer between stages (default for bundled YAMLs). | None. All payloads use shared memory. |
 | `MooncakeStoreConnector` | Cross-host KV transfer over TCP. Required for multi-node deployments. | `host`, `metadata_server`, `master`, `segment` (int bytes), `localbuf` (int bytes), `proto` (`"tcp"` / `"rdma"`). |

 A stage references a connector by name in its `input_connectors` / `output_connectors`:
@@ -137,7 +135,7 @@ stages:
 ### CLI flags

 | Flag | Description |
-| ------ | ------------- |
+|------|-------------|
 | `--deploy-config PATH` | Load a deploy YAML. **Optional** — when omitted, the bundled `vllm_omni/deploy/<model_type>.yaml` is auto-loaded by the model registry. |
 | `--stage-overrides JSON` | Per-stage JSON overrides, e.g. `'{"0":{"gpu_memory_utilization":0.5}}'`. Per-stage values always win over global flags. |
 | `--async-chunk` / `--no-async-chunk` | Flip the deploy YAML's `async_chunk:` bool. Unset (default) leaves the YAML value in force. |
@@ -251,7 +249,7 @@ CUDA_VISIBLE_DEVICES=0 vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni \
 Effective config per stage after the merge:

 | Stage | Field | Final value | Source |
-| ------- | ------- | ------------- | -------- |
+|-------|-------|-------------|--------|
 | 0 | `gpu_memory_utilization` | `0.9` | base YAML (overlay didn't touch stage 0) |
 | 0 | `max_num_seqs` | `8` | per-stage CLI (`--stage-overrides`) — wins over base `32` |
 | 0 | `max_model_len` | `16384` | global CLI |
@@ -275,14 +273,12 @@ when loading a deploy configuration.
 Examples:

 For offline inference (assuming the necessary dependencies have been imported):
-
 ```python
 model_name = "Qwen/Qwen2.5-Omni-7B"
 omni = Omni(model=model_name, deploy_config="/path/to/deploy_config.yaml")
 ```

 For online serving:
-
 ```bash
 vllm serve Qwen/Qwen2.5-Omni-7B --omni --port 8091 --deploy-config /path/to/deploy_config.yaml
 ```
@@ -4,8 +4,8 @@ When you want to add L4-level ***performance test*** cases, add entries to JSON

 | Model type | Runner | Example JSON files |
 | ---------- | ------ | ------------------ |
-| Omni (nightly) | `run_benchmark.py` | `test_qwen3_omni_no_async_chunk.json`, `test_qwen3_omni_async_chunk.json` (`full_model` without `slow` in `mark`) |
-| Omni (weekly) | `run_benchmark.py` | `test_qwen3_omni_async_chunk.json` (CUDA only), `test_qwen3_omni_vllm_text.json`, `test_qwen3_omni_multi_replicas.json` (`slow` in `mark`; **Perf Test** in `test-weekly.yml`) |
+| Omni (nightly) | `run_benchmark.py` | `test_qwen3_omni_no_async_chunk.json`, `test_qwen3_omni_async_chunk.json` (`full_model` in `mark`) |
+| Omni (weekly) | `run_benchmark.py` | `test_qwen3_omni_vllm_text.json`, `test_qwen3_omni_multi_replicas.json` (`slow` in `mark`; **Perf Test** in `test-weekly.yml`) |
 | TTS | `run_benchmark.py` | `test_tts.json`, `test_voxcpm2.json`, `test_higgs_audio_v3.json` |
 | Diffusion | `run_diffusion_benchmark.py` | `test_qwen_image_vllm_omni.json`, `test_bagel_vllm_omni.json`, `test_wan22_i2v_vllm_omni.json`, `test_cosmos3_vllm_omni.json`, … |

@@ -20,7 +20,7 @@ Diffusion cases are detected when the JSON has `server_type` (typically `"vllm-o

 #### Running perf cases

-Pass **`--test-config-file`** to load one JSON file, or omit it for the bulk scan above. In either mode, pytest **`-m`** filters each case using its JSON `mark`. A single file can contain nightly, weekly, and platform-specific case objects. For example, the nightly object in `test_qwen3_omni_async_chunk.json` declares both H100 and A3, while its `slow` weekly object is CUDA-only; there is no NPU weekly counterpart. Use `-m "H100 and full_model and not slow"`, `-m "H100 and full_model and slow"`, or `-m "npu"` to select the intended schedule and platform.
+Pass **`--test-config-file`** to run one JSON file as-is, or omit it for the bulk scan above and filter with pytest **`-m`** on each case's JSON `mark` (for example `pytest … run_benchmark.py -m "full_model and tts and H100"` or `-m "slow and omni and H100"` for weekly Omni configs).

 ```JSON
 {
@@ -75,7 +75,7 @@ Omit `mark` only for configs not meant to be filtered by `-m`. `server_type` is

 Optional top-level field on each perf JSON **case object** (one per `test_name`). `run_benchmark.py` and `run_diffusion_benchmark.py` read it via `tests.dfx.conftest.resolve_pytest_marks` and attach the marks to the corresponding `pytest.param`, so you can filter locally with `-m`.

-When `mark` is present, it must be an **array** with exactly one ``hardware_marks`` object (same shape as `@hardware_test` / `hardware_marks()` in `tests/helpers/mark.py`), followed by registered pytest marker name strings such as `full_model`, `slow`, `omni`, `tts`, `diffusion`, or `local_model`.
+When `mark` is present, it must be an **array** with exactly one ``hardware_marks`` object (same shape as `@hardware_test` / `hardware_marks()` in `tests/helpers/mark.py`), followed by registered pytest marker name strings such as `full_model`, `omni`, `tts`, `diffusion`, or `local_model`.

 Supported form:

@@ -142,18 +142,11 @@ Examples:
 pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py -m "full_model and H100 and diffusion"
 pytest -s -v tests/dfx/perf/scripts/run_benchmark.py -m "full_model and omni and H100"

-# Single file (same selectors as the CI Perf steps)
+# Single file (same as nightly CI Perf steps)
 pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py \
  --test-config-file tests/dfx/perf/tests/test_bagel_vllm_omni.json
 pytest -s -v tests/dfx/perf/scripts/run_benchmark.py \
-  --test-config-file tests/dfx/perf/tests/test_qwen3_omni_async_chunk.json \
-  -m "H100 and full_model and not slow"
-pytest -s -v tests/dfx/perf/scripts/run_benchmark.py \
-  --test-config-file tests/dfx/perf/tests/test_qwen3_omni_async_chunk.json \
-  -m "H100 and full_model and slow"
-pytest -s -v tests/dfx/perf/scripts/run_benchmark.py \
-  --test-config-file tests/dfx/perf/tests/test_qwen3_omni_async_chunk.json \
-  -m "npu"
+  --test-config-file tests/dfx/perf/tests/test_qwen3_omni_async_chunk.json
 ```

 <!-- markdownlint-disable-next-line MD051 -->
@@ -322,15 +322,6 @@ Each 1-second window records:

 On shutdown the server also logs a short summary (`loop_active_pct`, per-replica queue averages/maxima).

-`loop_idle` and `loop_active` count loop iterations, so their absolute scale is
-tied to which orchestration loop is running. Under the default poll loop an idle
-orchestrator records roughly one iteration per millisecond. Under the
-event-driven loop (`VLLM_OMNI_EVENT_DRIVEN_ORCH=1`, see
-[Speech API](../serving/speech_api.md#orchestration-loop-experimental)) an idle
-orchestrator wakes only once per 0.5 s reconcile timeout, while a busy one still
-records one iteration per routed output. Window counts and the `loop_active_pct`
-summary are therefore not comparable across the two modes.
-
 ### Relationship to other diagnostics

 This monitor is intentionally separate from the existing profiling tools:
@@ -63,7 +63,7 @@ vLLM-omni provides `CFGParallelMixin` that encapsulates all CFG parallel logic.

 ### N-Branch CFG (3+ branches)

-Some models require more than 2 CFG branches. For example, Bagel and OmniGen2 use 3 branches.
+Some models require more than 2 CFG branches. For example, Bagel and OmniGen2 use 3 branches, DreamID Omni uses 4 branches.

 `predict_noise_with_multi_branch_cfg()` handles these by automatically dispatching N branches across M GPUs using round-robin (rule: branch `i` → rank `i % M`):

@@ -14,12 +14,12 @@ specified in the [Host Weight Runtime module design](../module/host_weight_runti

 ## Status

-The implementation provides contracts and a CPU local-filesystem store. The
-diffusion consumer additionally defines typed,
+The first implementation provides contracts and a CPU local-filesystem store.
+The initial diffusion consumer contract additionally defines typed,
 representation-independent final-layout identity/restoration mechanics plus a
-concrete BF16-with-preserved-FP32 policy for MiniMax H3 and
-`black-forest-labs/FLUX.2-klein-4B`. The opt-in no-AllGather DLO integration
-selects, publishes, restores, and transfers these artifacts.
+concrete BF16-with-preserved-FP32 policy for MiniMax H3. It remains
+library-only: no loader or DLO path selects, publishes, restores, or transports
+that artifact yet.

 V1 includes:

@@ -33,12 +33,13 @@ V1 includes:

 V1 does not include:

- default-on activation or consumers outside no-AllGather DLO;
- online FP8, quantized, merged-adaptation, or additional model producers;
- HWR interaction with DLO AllGather;
+- a public CLI, loader activation, or default-on model integration;
+- lease handoff to DLO or another transport consumer;
+- FP8, quantized, merged-adaptation, or additional model producers;
+- CUDA registration, pinned staging, H2D scheduling, or GPU kernels;
 - a remote artifact provider or cross-node coordination;
 - automatic eviction; or
- a change to DLO collective or execution behavior.
+- a change to DLO AllGather or no-AllGather behavior.

 ## Motivation and use cases

@@ -254,8 +255,7 @@ The contract is intentionally separate from loader activation:
 - `FinalLayoutBF16Producer` accepts only the matching identity context and a
  finalized CPU model. It is `POST_LOAD_ONLY` and `SINGLE_PROCESS` per exact TP
  coordinate. Its BF16 policy preserves model-declared FP32 parameters and
-  buffers, revalidates MiniMax H3 mixed-precision invariants, and revalidates
-  FLUX.2-klein's two block stacks, packed QKV mapping, and BF16 base layout.
+  buffers and revalidates MiniMax H3 mixed-precision invariants.

 Other representations reuse source identity, typed parallel identity, tensor
 ownership, and exact restoration only when their policy proves those semantics.
@@ -196,15 +196,16 @@ adopt it.

 ### Final-layout Host Weight Runtime consumer

-> **Status:** PR2 landed in
-> [PR #6486](https://github.com/vllm-project/vllm-omni/pull/6486). PR3 adds
-> registered direct H2D plus generic HWR publication/source-digest
-> optimizations without changing AllGather behavior.
+> **Status:** PR2 implementation. The representation-independent identity,
+> producer, and restoration contracts landed in
+> [PR #6445](https://github.com/vllm-project/vllm-omni/pull/6445); this consumer
+> wires the final-layout BF16 path into eligible no-AllGather DLO.

 Final-layout Host Weight Runtime (HWR) backing is opt-in and currently applies
 only to no-AllGather DLO. Enable it with
 `--host-weight-runtime-mode preferred` (or `required`) and
-`--host-weight-runtime-root <node-local-root>`.
+`--host-weight-runtime-root <node-local-root>`. Registration of shared mappings
+and direct asynchronous H2D remain a separate PR3 transport change.

 The modes express operator fallback policy, not different artifact formats:

@@ -220,15 +221,9 @@ model revision and parallel layout with `required`. TP coordinates have distinct
 identities, while equivalent DP replicas share them.

 The current producer/consumer boundary is the model-declared final-layout BF16
-contract (MiniMax H3 and `black-forest-labs/FLUX.2-klein-4B`). The FLUX.2-klein
-contract covers both transformer block stacks, constructor-stable packed QKV
-mapping state, BF16 parameters, and any persistent loader-owned `beta`/`eps`
-buffers. The shared HWR machinery supports ordinary-loader final layouts for
-TP1 and TP2 rank identities plus SP layout identities. FLUX.2-klein evidence
-in this change is TP1-only; its TP2/SP layouts rely on the existing
-per-coordinate identity mechanics and remain unmeasured. Online quantization,
-HSDP, LoRA/adapted weights, and non-default load formats remain ineligible.
-HWR mode
+contract (MiniMax H3 today). It supports ordinary-loader final layouts for TP1
+and TP2 rank identities plus SP layout identities; online quantization, HSDP,
+LoRA/adapted weights, and non-default load formats remain ineligible. HWR mode
 `disabled`, DLO-disabled, and DLO AllGather configurations stop before source
 identity or store construction and retain the existing checkpoint-mmap or
 ordinary-loader path.
@@ -259,44 +254,6 @@ outcomes are authoritative:
 Checkpoint mmap remains an unchanged control path whenever final-layout HWR is
 not selected.

-Local source identity and publication avoid repeated full-payload passes while
-preserving the same semantic contract:
-
- Canonical files without a trusted immutable Hub blob identity are hashed in
-  parallel. Their content IDs are cached per storage domain under the HWR root
-  and reused only when the path, inode, size, timestamps, symlink target, and
-  cache-record checksum still match. Corrupt entries are rebuilt; cache-lock or
-  cache-I/O failure falls back to hashing the canonical file directly.
- Producers that emit payload bytes in canonical storage-key order may declare
-  `ordered=True`. The filesystem writer then computes file and tensor SHA256
-  values during the write and overlaps payload `fsync` with later producer
-  work. Producers without that guarantee retain unordered writes and use a
-  parallel readback checksum fallback.
- Manifest and `READY` publication still wait for every payload `fsync` and
-  checksum to complete. These optimizations do not weaken artifact validation
-  or change lease ownership.
-
-#### Registered mmap transport
-
-After DLO takes an HWR lease, the no-AllGather backend may register the lease's
-complete immutable mapped ranges under the existing `pin_cpu_memory` policy.
-Registration is transport state: it does not change artifact identity, the
-store, tensor ownership, or H2D payload. On success, each tensor view copies
-directly into the existing rotating HBM block buffers and the two private host
-staging slots are not allocated.
-
-`--dlo-host-registration-limit-gib` is an optional per-worker preflight ceiling
-over page-aligned registered bytes. Zero adds no ceiling. A disabled pinned
-memory policy, unsupported platform/capability, over-budget mapping, or fully
-rolled-back registration error selects the existing two-slot staging path. A
-partial registration that cannot be rolled back aborts startup because closing
-the lease would unmap memory still owned by the platform.
-
-Direct checkpoint mmap remains unchanged and continues to use staging. It may
-require loader-owned per-block transforms, while the HWR artifact already
-contains final runtime bytes. DLO AllGather never receives an HWR final-layout
-lease and therefore never enters this registration path.
-
 #### Pre-service transaction boundary

 The startup transaction does not end at restore commit. A lease-backed model is
@@ -360,7 +317,6 @@ loader owns
  -> backend takes once before asynchronous work
  -> backend drains pending H2D work
  -> backend releases hooks, staging, and model references
-  -> backend unregisters every mapped range
  -> backend closes lease
 ```

@@ -370,15 +326,13 @@ it. Once the backend takes ownership, only backend abort or teardown may drain
 work and close it.

 The implementation keeps the final-layout lease through backend setup and
-initial prefetch. Successful registration copies directly from immutable HWR
-views; otherwise the backend uses the existing two bounded rank-local staging
-slots. Transactional cleanup drains device work, removes source references,
-unregisters mappings, and only then closes the lease. An unregistration failure
-retains both registration and lease for retry/process teardown. Preferred mode
-then uses the runner's fresh canonical retry; required mode propagates the
-failure.
+initial prefetch. The backend uses the existing two bounded rank-local staging
+slots for the immutable HWR tensors, and its transactional `enable()` cleanup
+removes partial hooks and closes the lease before reporting a setup failure.
+Preferred mode then uses the runner's fresh canonical retry; required mode
+propagates the failure.

-#### PR2 and PR3 promotion gates
+#### PR2 promotion gates

 - Warm hit performs zero ordinary DiT materialization and zero producer calls.
 - Shared warm finalization changes neither restored bytes nor backing pointers.
@@ -390,10 +344,6 @@ failure.
 - Disabled mode and AllGather emit zero final-layout HWR interaction.
 - The lease carrier rejects duplicate take and serialization.
 - Backend setup or prefetch failure drains asynchronous work before lease close.
- Registration is all-or-nothing; rollback/unregistration failure never closes
-  a mapping still owned by the platform.
- Registered HWR transport bypasses host staging while preserving output and
-  H2D payload; unsupported registration retains the bounded staging path.
 - Compatible checkpoint mmap remains an unchanged benchmark and control path.
 - Prewarm uses one matching producer cohort per TP/SP topology and storage
  domain.
@@ -444,12 +394,11 @@ reconstructs those tensors with their recorded layouts. Other online methods
 must use `--dlo-no-use-allgather` or disable online quantization until their
 runtime layouts are validated.

-The Host Weight Runtime representation, publication, and no-AllGather consumer
-contracts are merged; see
-[RFC #6414](https://github.com/vllm-project/vllm-omni/issues/6414),
-[PR #6445](https://github.com/vllm-project/vllm-omni/pull/6445), and
-[PR #6486](https://github.com/vllm-project/vllm-omni/pull/6486). Registered
-direct H2D is an optional transport layer over that merged lease contract.
+The Host Weight Runtime representation and publication contracts are merged;
+see [RFC #6414](https://github.com/vllm-project/vllm-omni/issues/6414) and
+[PR #6445](https://github.com/vllm-project/vllm-omni/pull/6445). The planned
+no-AllGather consumer above is the PR2 implementation; registration and direct
+asynchronous H2D remain a separate transport follow-up.

 ## Validation coverage

@@ -462,12 +411,8 @@ Current source-level validation includes:
 - ordinary-loader fallback for per-tensor online FP8 linears followed by DLO
  sharding of finalized weights and scales;
 - exact loader-to-backend plan transfer and ordinary-loader fallback;
- ordered publication hashing, overlapped durability, unordered parallel
-  checksum fallback, and node-local source-digest reuse/invalidation;
 - rank-local mmap source retention, bounded two-slot staging, and adapter
  transforms without parameter-side flags;
- read-only registration preflight, direct source-to-device copies, safe
-  fallback, partial rollback, retryable unregistration, and lease ordering;
 - resident-layer requests requiring no-AllGather;
 - DP request-wave validation for denoising-step compatibility;
 - bounded component allocator-cache retention, conservative/forced release,
@@ -6,7 +6,7 @@ This document describes how vLLM-Omni exposes Prometheus metrics for multi-stage

 - Expose pipeline-level request and latency metrics that span the full multi-stage execution (orchestrator scope).
 - Preserve all upstream vLLM per-engine metrics (`vllm:*`) for stages backed by an AR LLM engine, and reshape their `engine` label into `stage` + `replica` so multi-replica deployments gain per-replica visibility automatically.
- Expose per-modality SLO metrics that the upstream `vllm:*` families do not capture — audio TTFP / RTF / duration / frames / streaming continuity / silent-loss, plus image and diffusion workload, queueing, execution, and memory signals.
+- Expose per-modality SLO metrics that the upstream `vllm:*` families do not capture — audio TTFP / RTF / duration / frames / streaming continuity / silent-loss.
 - Expose per-replica-edge cross-stage transfer metrics so the slack between E2E latency and the sum of per-stage `gen_time` (queueing, serialization, network) becomes attributable.
 - Keep the metrics collection overhead low enough that it does not regress TTFA or throughput.

@@ -20,7 +20,7 @@ vLLM's `unregister_vllm_metrics()` function strips every `prometheus_client` col

 ### The Problem

-vLLM-Omni runs multiple engine instances (stages × replicas) within a single process, coordinated by an Orchestrator. The pipeline needs its own metrics — aggregate request counts, end-to-end latency across all stages, per-modality SLO signals, and cross-stage transfer attribution — that do not exist in upstream vLLM. All pipeline-level metrics use the `vllm_omni:` prefix to distinguish them from upstream per-engine metrics. At import time (see `vllm_omni/patch.py`) we replace `unregister_vllm_metrics()` with a scoped version that still strips upstream `vllm:*` collectors before each new `PrometheusStatLogger` registers (so multi-engine processes don't crash on duplicate registration), but preserves anything prefixed `vllm_omni:` / `vllm_omni`.
+vLLM-Omni runs multiple engine instances (stages × replicas) within a single process, coordinated by an Orchestrator. The pipeline needs its own metrics — aggregate request counts, end-to-end latency across all stages, per-modality SLO signals, and cross-stage transfer attribution — that do not exist in upstream vLLM. All pipeline-level metrics use the `vllm:omni_` prefix to distinguish them from upstream per-engine metrics. At import time (see `vllm_omni/patch.py`) we replace `unregister_vllm_metrics()` with a scoped version that still strips upstream `vllm:*` collectors before each new `PrometheusStatLogger` registers (so multi-engine processes don't crash on duplicate registration), but preserves anything prefixed `vllm:omni_` / `vllm_omni`.

 Upstream per-engine metrics retain the `vllm:` prefix but are now registered by `OmniPrometheusStatLogger`, a thin subclass of upstream's `PrometheusStatLogger` that reshapes the single `engine` label into a `stage` + `replica` pair (see "OmniPrometheusStatLogger wrap" below).

@@ -38,7 +38,7 @@ Upstream per-engine metrics retain the `vllm:` prefix but are now registered by
                                   |
        +--------+--------+--------+--------+--------+
        |                                            |
-   vllm_omni:*                                    vllm:*
+   vllm:omni_*                                    vllm:*
   collectors                                  collectors
        |                                            |
   +----+--------+   +-----------+   +----------+   +-----------+
@@ -58,30 +58,17 @@ Upstream per-engine metrics retain the `vllm:` prefix but are now registered by

 ### Data Flow

-There are five independent paths for metric collection.
+There are four independent paths for metric collection.

-**Path 1: Pipeline-level metrics (`vllm_omni:*`)**
+**Path 1: Pipeline-level metrics (`vllm:omni_*`)**

 `OmniPrometheusMetrics` registers the Gauge / Counter / Histogram collectors at import time. It is instantiated once per entrypoint, labeled with the model name. The entrypoint calls its methods as requests progress:

 - `set_running(n)` / `set_waiting(n)` — updated after each request completes. The running count comes from `OmniRequestCounter`, a simple counter incremented/decremented by the Orchestrator as it tracks requests. Waiting is derived as `total - running`.
- `request_succeeded(e2e_seconds, finished_reason="stop")` — recorded when a request finishes at the final stage. `finished_reason` is extracted from `engine_outputs.outputs[0].finish_reason` (vLLM `CompletionOutput` convention) and increments `vllm_omni:requests_success_total{finished_reason}`.
- `request_failed()` — recorded by the cleanup path when a request exits without natural completion. Internally maps to `finished_reason="abort"` on the existing completion Counter.
- `inc_requests_failed(reason)` — increments the dedicated failure-attribution Counter once per request. Reasons are normalized to the bounded set `client_abort`, `client_disconnect`, `stage_error`, and `unknown`.
+- `request_succeeded(e2e_seconds, finished_reason="stop")` — recorded when a request finishes at the final stage. `finished_reason` is extracted from `engine_outputs.outputs[0].finish_reason` (vLLM `CompletionOutput` convention) and increments `vllm:omni_requests_success_total{finished_reason}`.
+- `request_failed()` — recorded by the cleanup path when a request exits without natural completion. Internally maps to `finished_reason="abort"` so a single Counter family covers both natural and aborted completion.

-**Path 2: Image and diffusion metrics**
-
-Image and diffusion metrics use two cooperating collectors. `OmniPrometheusMetrics` owns pipeline/stage workload families, while `OmniModalityMetrics` owns per-replica diffusion breakdowns. Finished stage messages are consumed once in `OmniBase._process_single_result`, which prevents replayed terminal messages from incrementing Counters or Histograms twice.
-
- `stage_gen_time_s`, `stage_in_queue_s`, image workload, inference-step, and per-stage peak-memory values are emitted from `StageRequestStats` when a stage finishes. `image_pixels` and `image_count_total` are restricted to image outputs; `num_inference_steps` is restricted to diffusion stages.
- Diffusion engine timings are accumulated per request by `OrchestratorAggregator.accumulate_diffusion_metrics`. Engine-side millisecond values are converted to seconds before `observe_modality_at_finalize(...)` dispatches the per-replica Histogram observations.
- `request_queue_wait_s` is emitted once at final request completion from `pipeline_timings["queue_wait_ms"]`. A present value of `0` is a valid observation; a missing key produces no sample.
- `stage_waiting_requests` is the sum of the latest scheduler snapshots for all live replicas in a stage. AR snapshots arrive through `SchedulerStats`; diffusion snapshots ride normal diffusion output metrics. A dead replica's snapshot is removed. Because this deliberately reuses existing message paths, the gauge can retain its last value while a replica produces no output.
- `kv_wait_s` measures the AR scheduler interval from entering the KV-transfer-free wait state until extraction acknowledgement. The sample is carried to the Orchestrator through the existing engine output and labeled by connector type. Abort/error/removal paths discard incomplete timers rather than emitting partial waits.
-
-Zero and missing values have different meanings. Valid zero-duration queue observations are recorded, while unavailable optional measurements are omitted instead of being exported as synthetic zeroes. `peak_memory_mb`, `diffusion_forward_s`, `diffusion_kv_load_s`, `vae_decode_s`, and `kv_wait_s` therefore appear only when their data source is active.
-
-**Path 3: Audio modality metrics (`vllm_omni:audio_*`)**
+**Path 2: Audio modality metrics (`vllm:omni_audio_*`)**

 `OmniModalityMetrics` registers seven audio families with `{model_name, stage, replica}` (plus an extra `threshold_ms` / `reason` label on the two extra-cardinality Counters). Three observation sites:

@@ -89,7 +76,7 @@ Zero and missing values have different meanings. Valid zero-duration queue obser
 - `observe_audio_first_packet(...)` — called from the OpenAI SSE audio branch in `serving_chat.py` on the first audio packet for a request. The once-per-request guard is held by `ClientRequestState.first_audio_ts`. The `request_arrival_ts` anchor is stored in `ClientRequestState` by `async_omni.generate()`, computed at request entry.
 - `observe_audio_streaming_finalize(...)` — called from `serving_chat.py` after the streaming chunk loop exhausts. It runs the per-chunk player simulation from `vllm_omni/benchmarks/audio_continuity.py` to compute the worst-case underrun and emits `audio_underrun_s` plus (when the request stayed below the threshold) `audio_continuity_ok_total{threshold_ms}`. Per-chunk PCM byte counts and arrival timestamps are recorded by the same audio branch that updates `first_audio_ts`.

-**Path 4: Cross-stage transfer metrics (`vllm_omni:transfer_*`)**
+**Path 3: Cross-stage transfer metrics (`vllm:omni_transfer_*`)**

 `OmniTransferMetrics` registers four Histogram families with `{model_name, from_stage, from_replica, to_stage, to_replica}` labels. Each observation corresponds to one physical transfer hop (one chunk between adjacent stages), not the per-request accumulated total — so the histograms track per-transfer distribution.

@@ -100,7 +87,7 @@ The hook lives in `OrchestratorAggregator.record_transfer_tx` and `record_transf

 Defensive fail-safe: if `transfer_emitter` or `replica_resolver` is missing, or the resolver returns `None` for either side, the emit is skipped silently (the underlying `TransferEdgeStats` accumulation is unaffected).

-**Path 5: Per-engine metrics (`vllm:*`, stage/replica wrap)**
+**Path 4: Per-engine metrics (`vllm:*`, stage/replica wrap)**

 The Orchestrator instantiates `OmniPrometheusStatLogger` (a thin subclass of upstream `vllm.v1.metrics.loggers.PrometheusStatLogger`) and feeds it scheduler stats and iteration stats after processing each batch of engine outputs. This populates the standard ~37 vLLM metric families (TTFT, ITL, TPOT, KV cache usage, etc.) using the same upstream code path — but with the `engine` label reshaped into `stage` + `replica` so multi-replica deployments produce distinct series per replica. See the next section for the wrap mechanics.

@@ -110,9 +97,9 @@ The Orchestrator runs in a background thread. The API server (OmniBase) runs in

 ### Metric Registration and Lifecycle

-All `vllm_omni:*` collectors are registered once when their owning class (`OmniPrometheusMetrics` / `OmniModalityMetrics` / `OmniTransferMetrics`) is imported. Per-`(stage, replica)` labels are bound lazily on first observation to avoid registering label sets for combinations that never produce data.
+All `vllm:omni_*` collectors are registered once when their owning class (`OmniPrometheusMetrics` / `OmniModalityMetrics` / `OmniTransferMetrics`) is imported. Per-`(stage, replica)` labels are bound lazily on first observation to avoid registering label sets for combinations that never produce data.

-The `prometheus_client` default registry holds all collectors. FastAPI's `/metrics` endpoint serves the default registry, so `vllm_omni:*` and the wrapped `vllm:*` metrics appear in the same scrape response alongside `http_*` and `process_*` metrics from the instrumentator and the Python client runtime.
+The `prometheus_client` default registry holds all collectors. FastAPI's `/metrics` endpoint serves the default registry, so `vllm:omni_*` and the wrapped `vllm:*` metrics appear in the same scrape response alongside `http_*` and `process_*` metrics from the instrumentator and the Python client runtime.

 ## OmniPrometheusStatLogger Wrap

@@ -143,11 +130,11 @@ A reverse map `(stage_id, replica_id) -> flat_idx` is maintained on the Orchestr

 ## Gating: `--log-stats`

-All metrics — both the omni-specific `vllm_omni:*` families and the upstream `vllm:*` wrap families — are gated by the user's `--log-stats` CLI flag (default off). The flag is plumbed from `OmniBase.__init__(log_stats=...)` through `AsyncOmniEngine` to the stage-spawn helpers and to the three Prometheus metric classes (`OmniPrometheusMetrics` / `OmniModalityMetrics` / `OmniTransferMetrics`), and is forwarded to `Orchestrator._init_metrics_state(...)`.
+All metrics — both the 15 `vllm:omni_*` families and the ~65 upstream `vllm:*` wrap families — are gated by the user's `--log-stats` CLI flag (default off). The flag is plumbed from `OmniBase.__init__(log_stats=...)` through `AsyncOmniEngine` to the stage-spawn helpers and to the three Prometheus metric classes (`OmniPrometheusMetrics` / `OmniModalityMetrics` / `OmniTransferMetrics`), and is forwarded to `Orchestrator._init_metrics_state(...)`.

 Behavior with `--log-stats=off` (default):

- The three `Omni*Metrics` classes register their module-level Gauge / Counter / Histogram families at import time (prometheus_client requires up-front registration), but each `observe / inc / set` method early-returns. The per-label child series for `vllm_omni:*` stay materialized but never have data written to them.
+- The three `Omni*Metrics` classes register their module-level Gauge / Counter / Histogram families at import time (prometheus_client requires up-front registration), but each `observe / inc / set` method early-returns. The per-label child series for `vllm:omni_*` stay materialized but never have data written to them.
 - `OmniPrometheusStatLogger` is not constructed in `_init_metrics_state`, so the ~65 upstream `vllm:*` wrap families are not registered in the default registry at all.
 - The engine core's `Scheduler.make_stats()` also short-circuits inside upstream (`if not self.log_stats: return None`), so no `SchedulerStats` is produced per step — the per-iteration cost is bounded by the existing upstream gate.

@@ -175,43 +162,10 @@ second.

 | Metric | Type | Labels | Description |
 |--------|------|--------|-------------|
-| `vllm_omni:num_requests_running` | Gauge | `model_name` | Requests currently executing across all stages |
-| `vllm_omni:num_requests_waiting` | Gauge | `model_name` | Requests queued but not yet scheduled |
-| `vllm_omni:requests_success_total` | Counter | `model_name`, `finished_reason` | Total requests by completion reason ({stop, length, abort, ...}); aborts cover client-disconnect / cancellation paths in addition to upstream `FinishReason.ABORT` |
-| `vllm_omni:e2e_request_latency_s` | Histogram | `model_name` | Pipeline-global end-to-end latency in seconds |
-
-### Image and diffusion service-level metrics
-
-| Metric | Type | Labels | Description |
-|--------|------|--------|-------------|
-| `vllm_omni:stage_gen_time_s` | Histogram | `model_name`, `stage`, `stage_type` | Stage submit to finished output; includes in-stage queueing |
-| `vllm_omni:request_queue_wait_s` | Histogram | `model_name` | Orchestration-layer queue wait; a present zero is recorded |
-| `vllm_omni:stage_waiting_requests` | Gauge | `model_name`, `stage` | Sum of the latest waiting snapshots across live replicas in the stage |
-| `vllm_omni:stage_in_queue_s` | Histogram | `model_name`, `stage` | Diffusion scheduler wait from enqueue to initial execution admission |
-| `vllm_omni:num_inference_steps` | Histogram | `model_name` | Denoising-step distribution for diffusion stages |
-| `vllm_omni:image_count_total` | Counter | `model_name` | Cumulative number of generated image outputs |
-| `vllm_omni:image_pixels` | Histogram | `model_name` | Pixel-count distribution for image outputs |
-| `vllm_omni:peak_memory_mb` | Gauge | `model_name`, `stage` | Positive per-stage peak-memory samples reported by engine outputs |
-| `vllm_omni:requests_failed_total` | Counter | `model_name`, `reason` | Request failures with bounded reason values (`client_abort`, `client_disconnect`, `stage_error`, `unknown`) |
-| `vllm_omni:kv_wait_s` | Histogram | `model_name`, `connector_type` | Completed AR KV-transfer wait intervals, grouped by connector backend |
-
-### Diffusion execution breakdown
-
-Labels: `{model_name, stage, replica}`.
-
-| Metric | Type | Description |
-|--------|------|-------------|
-| `vllm_omni:diffusion_exec_s` | Histogram | Core diffusion-step execution time per request |
-| `vllm_omni:diffusion_exec_per_step_s` | Histogram | Core diffusion execution divided by inference-step count |
-| `vllm_omni:diffusion_preprocess_s` | Histogram | Diffusion input preprocessing time |
-| `vllm_omni:diffusion_postprocess_s` | Histogram | Diffusion output postprocessing time |
-| `vllm_omni:vae_decode_s` | Histogram | VAE decode time when the engine reports it |
-| `vllm_omni:diffusion_forward_s` | Histogram | Forward-only denoise-loop time when pipeline profiling is enabled |
-| `vllm_omni:diffusion_kv_load_s` | Histogram | Diffusion-side KV receive/load time when upstream KV is used |
-| `vllm_omni:image_ttfp_s` | Histogram | Image-stage submit to first materialized image output |
-| `vllm_omni:denoise_step_latency_s` | Histogram | Mean diffusion forward time per denoise step for image output stages |
-
-The optional breakdown and memory families are sparse by design: when an engine does not produce the source measurement, no sample is emitted. This differs from queue timings, where an explicitly measured zero is meaningful and is retained.
+| `vllm:omni_num_requests_running` | Gauge | `model_name` | Requests currently executing across all stages |
+| `vllm:omni_num_requests_waiting` | Gauge | `model_name` | Requests queued but not yet scheduled |
+| `vllm:omni_requests_success_total` | Counter | `model_name`, `finished_reason` | Total requests by completion reason ({stop, length, abort, ...}); aborts cover client-disconnect / cancellation paths in addition to upstream `FinishReason.ABORT` |
+| `vllm:omni_e2e_request_latency_s` | Histogram | `model_name` | Pipeline-global end-to-end latency in seconds |

 ### Audio (7)

@@ -219,13 +173,13 @@ Labels: `{model_name, stage, replica}` plus the listed extra label.

 | Metric | Type | Extra label | Description |
 |--------|------|-------------|-------------|
-| `vllm_omni:audio_ttfp_s` | Histogram | — | Time from request arrival to first audio packet/frame |
-| `vllm_omni:audio_duration_s` | Histogram | — | Audio content duration (`audio_frames / sample_rate`) |
-| `vllm_omni:audio_rtf` | Histogram | — | Real-time factor `stage_gen_time_s / audio_duration_s` (SLO `< 1`); uses `RTF_BUCKETS` |
-| `vllm_omni:audio_frames_total` | Counter | — | Cumulative audio frames generated |
-| `vllm_omni:audio_underrun_s` | Histogram | — | Per-request worst-case player deficit; `> 0` indicates listener heard silent gaps |
-| `vllm_omni:audio_continuity_ok_total` | Counter | `threshold_ms` | Incremented when the request's worst underrun stayed below `threshold_ms` |
-| `vllm_omni:audio_skipped_requests_total` | Counter | `reason` | Silent-loss counter — code2wav rejected malformed codec input and returned `200 OK` with empty audio |
+| `vllm:omni_audio_ttfp_s` | Histogram | — | Time from request arrival to first audio packet/frame |
+| `vllm:omni_audio_duration_s` | Histogram | — | Audio content duration (`audio_frames / sample_rate`) |
+| `vllm:omni_audio_rtf` | Histogram | — | Real-time factor `stage_gen_time_s / audio_duration_s` (SLO `< 1`); uses `RTF_BUCKETS` |
+| `vllm:omni_audio_frames_total` | Counter | — | Cumulative audio frames generated |
+| `vllm:omni_audio_underrun_s` | Histogram | — | Per-request worst-case player deficit; `> 0` indicates listener heard silent gaps |
+| `vllm:omni_audio_continuity_ok_total` | Counter | `threshold_ms` | Incremented when the request's worst underrun stayed below `threshold_ms` |
+| `vllm:omni_audio_skipped_requests_total` | Counter | `reason` | Silent-loss counter — code2wav rejected malformed codec input and returned `200 OK` with empty audio |

 ### Cross-stage transfer (4)

@@ -233,10 +187,10 @@ Labels: `{model_name, from_stage, from_replica, to_stage, to_replica}`.

 | Metric | Type | Description |
 |--------|------|-------------|
-| `vllm_omni:transfer_size_bytes` | Histogram | Per-transfer payload size in bytes |
-| `vllm_omni:transfer_tx_s` | Histogram | Sender-side time (serialize + submit to connector) |
-| `vllm_omni:transfer_rx_s` | Histogram | Receiver-side time (recv + deserialize) |
-| `vllm_omni:transfer_in_flight_s` | Histogram | Network in-flight time (TX done → RX recv start) |
+| `vllm:omni_transfer_size_bytes` | Histogram | Per-transfer payload size in bytes |
+| `vllm:omni_transfer_tx_s` | Histogram | Sender-side time (serialize + submit to connector) |
+| `vllm:omni_transfer_rx_s` | Histogram | Receiver-side time (recv + deserialize) |
+| `vllm:omni_transfer_in_flight_s` | Histogram | Network in-flight time (TX done → RX recv start) |

 ### LLM stage-level (wrapped `vllm:*`)

@@ -249,7 +203,7 @@ After the wrap, every upstream `vllm:*` family — TTFT, ITL, TPOT, e2e latency,
  - `SECONDS_FAST_BUCKETS` (0.001 s – 60 s) for fine-grained cross-stage transfer and audio-underrun values that need millisecond-level resolution.
 - Counters use the `_total` suffix (auto-appended by `prometheus_client`).
 - Sizes use the `_bytes` suffix.
- All omni-specific families are prefixed `vllm_omni:`. The upstream `unregister_vllm_metrics()` function is monkey-patched to a scoped version that still strips upstream `vllm:*` collectors (so multi-engine init within one process does not crash on duplicate registration) but preserves anything prefixed `vllm_omni:` / `vllm_omni`.
+- All omni-specific families are prefixed `vllm:omni_`. The upstream `unregister_vllm_metrics()` function is monkey-patched to a scoped version that still strips upstream `vllm:*` collectors (so multi-engine init within one process does not crash on duplicate registration) but preserves anything prefixed `vllm:omni_` / `vllm_omni`.

 ## Logging vs. Prometheus

@@ -66,12 +66,6 @@ the boundary affected by the in-flight stage client/process refactor in
 [#5441](https://github.com/vllm-project/vllm-omni/pull/5441). Names and
 responsibilities proposed only by that PR are not current contracts.

-The orchestration loop also has an opt-in event-driven mode
-(`VLLM_OMNI_EVENT_DRIVEN_ORCH=1`, default off) proposed in
-[#5221](https://github.com/vllm-project/vllm-omni/pull/5221). It changes poll
-cadence only: the routing, ordering, and terminal-state contracts below hold
-identically on both loops.
-
 ## Ownership boundary

 This document owns `AsyncOmniEngine`, `Orchestrator`, request-state creation,
@@ -16,7 +16,7 @@ validation_paths:
  - tests/host_weight_runtime/**
 upstream_refs:
  - https://github.com/vllm-project/vllm-omni/issues/6414
-last_reviewed: 2026-08-25
+last_reviewed: 2026-08-21
 ---

 # Host Weight Runtime
@@ -84,13 +84,6 @@ another. `WeightArtifactIdentity` includes:
 - producer version, implementation fingerprint, manifest schema, and restorer
  schema.

-Loader integrations may persist content digests for canonical source shards in
-the selected storage domain. Reuse requires the same path, inode, size,
-timestamps, symlink target, and cache-record checksum. Corrupt records are
-rebuilt, and coordination or cache-I/O failure falls back to hashing the
-canonical source directly. This is an identity-computation optimization, not a
-second source of truth or an artifact substitution rule.
-
 The identity excludes transfer policy such as registered mmap versus private
 pinned staging. Those paths move the same host representation and must not
 produce duplicate artifacts.
@@ -244,12 +237,6 @@ Every publication computes full file and tensor hashes. Local lookup supports:
  and
 - `full_checksum`, which additionally reads and hashes every payload file.

-An ordered producer may compute file and tensor digests while payload bytes are
-written and overlap each closed payload's `fsync` with later producer work. An
-unordered producer retains parallel readback hashing. In both cases manifest
-and `READY` publication wait for every payload digest and `fsync`; the atomic
-publication and validation contract is unchanged.
-
 Filesystem verity is modeled but unsupported. Invalid artifacts receive an
 external deny marker before their shared lookup lock is released; a build owner
 then quarantines the immutable directory under the exclusive lock.
@@ -1,7 +1,7 @@
 # Installation

 !!! important
-    vLLM-Omni is released against the matching upstream vLLM major/minor version. vLLM-Omni 0.28.x requires vLLM 0.28.x; the stable v0.28.0 instructions pin vLLM 0.28.0.
+    vLLM-Omni is released against the matching upstream vLLM major/minor version. vLLM-Omni 0.26.x requires vLLM 0.26.x; the stable v0.26.0 instructions pin vLLM 0.26.0.

 vLLM-Omni supports the following hardware platforms:

@@ -34,7 +34,7 @@ vLLM-Omni is a Python library that supports the following GPU variants. The libr

 ### Pre-built wheels

-Note: Pre-built wheels are currently available for vLLM-Omni 0.11.0rc1, 0.12.0rc1, 0.14.0rc1, 0.14.0, 0.16.0, 0.18.0, 0.20.0, 0.21.0, 0.22.0, 0.23.0, 0.24.0, 0.25.0, and 0.26.0; the 0.28.0 wheels are published together with the v0.28.0 release this branch produces. If you need a newer unreleased revision, please [build from source](https://docs.vllm.ai/projects/vllm-omni/en/latest/getting_started/installation/gpu/#build-wheel-from-source).
+Note: Pre-built wheels are currently available for vLLM-Omni 0.11.0rc1, 0.12.0rc1, 0.14.0rc1, 0.14.0, 0.16.0, 0.18.0, 0.20.0, 0.21.0, 0.22.0, 0.23.0, 0.24.0, 0.25.0, and 0.26.0. If you need a newer unreleased revision, please [build from source](https://docs.vllm.ai/projects/vllm-omni/en/latest/getting_started/installation/gpu/#build-wheel-from-source).

 === "NVIDIA CUDA"

@@ -20,7 +20,7 @@ Therefore, it is recommended to install vLLM and vLLM-Omni with a **fresh new**

 vLLM-Omni is built based on vLLM. Please install it with command below.
 ```bash
-uv pip install vllm==0.28.0 --torch-backend=auto
+uv pip install vllm==0.26.0 --torch-backend=auto
 ```

 #### Installation of vLLM-Omni
@@ -39,13 +39,13 @@ uv pip install 'vllm-omni[demo]'
 # --8<-- [start:build-wheel-from-source]

 #### Installation of vLLM
-If you do not need to modify source code of vLLM, you can directly install the stable 0.28.0 release version of the library
+If you do not need to modify source code of vLLM, you can directly install the stable 0.26.0 release version of the library

 ```bash
-uv pip install vllm==0.28.0 --torch-backend=auto
+uv pip install vllm==0.26.0 --torch-backend=auto
 ```

-The 0.28.0 release of vLLM ships CUDA 13.0-compatible binaries by default. If you need a different CUDA variant or want to reuse an existing PyTorch installation, build vLLM from source instead.
+The 0.26.0 release of vLLM ships CUDA 13.0-compatible binaries by default. If you need a different CUDA variant or want to reuse an existing PyTorch installation, build vLLM from source instead.

 #### Installation of vLLM-Omni
 Since vllm-omni is rapidly evolving, it's recommended to install it from source
@@ -66,12 +66,12 @@ If you want to check, modify or debug with source code of vLLM, install the libr
 ```bash
 git clone https://github.com/vllm-project/vllm.git
 cd vllm
-git checkout v0.28.0
+git checkout v0.26.0
 ```
 Set up environment variables to get pre-built wheels. If there are internet problems, just download the whl file manually. And set `VLLM_PRECOMPILED_WHEEL_LOCATION` as your local absolute path of whl file.
 ```bash
-#For CUDA 13.0 (the default for v0.28.0; the wheel filename has no `+cu130` suffix)
-export VLLM_PRECOMPILED_WHEEL_LOCATION=https://github.com/vllm-project/vllm/releases/download/v0.28.0/vllm-0.28.0-cp38-abi3-manylinux_2_28_x86_64.whl
+#For CUDA 13.0 (the default for v0.26.0; the wheel filename has no `+cu130` suffix)
+export VLLM_PRECOMPILED_WHEEL_LOCATION=https://github.com/vllm-project/vllm/releases/download/v0.26.0/vllm-0.26.0-cp38-abi3-manylinux_2_28_x86_64.whl
 ```
 Install vllm with command below (If you have no existing PyTorch).
 ```bash
@@ -102,7 +102,7 @@ docker run --runtime nvidia --gpus 2 \
    --env "HF_TOKEN=$HF_TOKEN" \
    -p 8091:8091 \
    --ipc=host \
-    vllm/vllm-omni:v0.28.0 \
+    vllm/vllm-omni:v0.26.0 \
    vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni --port 8091
 ```

@@ -124,7 +124,7 @@ If you want to specify the base vLLM version:
 ```bash
 DOCKER_BUILDKIT=1 docker build \
  -f docker/Dockerfile.cuda \
-  --build-arg BASE_IMAGE=vllm/vllm-openai:v0.28.0 \
+  --build-arg BASE_IMAGE=vllm/vllm-openai:v0.26.0 \
  -t vllm-omni-cuda .
 ```

@@ -13,7 +13,7 @@ vLLM-Omni current recommends the steps in under setup through Docker Images.

 vLLM-Omni is built based on vLLM. Please install it with command below.
 ```bash
-uv pip install vllm==0.28.0+rocm723 --extra-index-url https://wheels.vllm.ai/rocm/0.28.0/rocm723
+uv pip install vllm==0.26.0+rocm723 --extra-index-url https://wheels.vllm.ai/rocm/0.26.0/rocm723
 ```

 #### Installation of vLLM-Omni
@@ -34,13 +34,13 @@ uv pip install onnxruntime-rocm
 # --8<-- [start:build-wheel-from-source]

 #### Installation of vLLM
-If you do not need to modify source code of vLLM, you can directly install the stable 0.28.0 release version of the library
+If you do not need to modify source code of vLLM, you can directly install the stable 0.26.0 release version of the library

 ```bash
-uv pip install vllm==0.28.0+rocm723 --extra-index-url https://wheels.vllm.ai/rocm/0.28.0/rocm723
+uv pip install vllm==0.26.0+rocm723 --extra-index-url https://wheels.vllm.ai/rocm/0.26.0/rocm723
 ```

-The pre-built 0.28.0 vLLM wheel targets ROCm 7.2.3. If you need a different ROCm stack or want to reuse an existing PyTorch installation, build vLLM from source instead.
+The pre-built 0.26.0 vLLM wheel targets ROCm 7.2.3. If you need a different ROCm stack or want to reuse an existing PyTorch installation, build vLLM from source instead.

 #### Installation of vLLM-Omni
 Since vllm-omni is rapidly evolving, it's recommended to install it from source
@@ -58,7 +58,7 @@ If you want to check, modify or debug with source code of vLLM, install the libr
 ```bash
 git clone https://github.com/vllm-project/vllm.git
 cd vllm
-git checkout v0.28.0
+git checkout v0.26.0
 python3 -m pip install -r requirements/rocm.txt
 python3 setup.py develop
 ```
@@ -130,7 +130,7 @@ docker run --rm \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  --env "HF_TOKEN=$HF_TOKEN" \
  -p 8091:8091 \
-  vllm/vllm-omni-rocm:v0.28.0 \
+  vllm/vllm-omni-rocm:v0.26.0 \
  --model Qwen/Qwen3-Omni-30B-A3B-Instruct --omni --port 8091
 ```

@@ -149,7 +149,7 @@ docker run --rm -it \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  --env "HF_TOKEN=$HF_TOKEN" \
  --entrypoint bash \
-  vllm/vllm-omni-rocm:v0.28.0
+  vllm/vllm-omni-rocm:v0.26.0
 ```

 # --8<-- [end:pre-built-images]
@@ -19,10 +19,10 @@ uv venv --python 3.12 --seed
 source .venv/bin/activate

 # On CUDA
-uv pip install vllm==0.28.0 --torch-backend=auto
+uv pip install vllm==0.26.0 --torch-backend=auto

 # On ROCm
-uv pip install vllm==0.28.0+rocm723 --extra-index-url https://wheels.vllm.ai/rocm/0.28.0/rocm723
+uv pip install vllm==0.26.0+rocm723 --extra-index-url https://wheels.vllm.ai/rocm/0.26.0/rocm723

 git clone https://github.com/vllm-project/vllm-omni.git
 cd vllm-omni
@@ -34,7 +34,7 @@ For additional installation methods — please see the [installation guide](inst
 !!! note
    It is important to install the same major & minor version of vLLM and vLLM Omni, otherwise things may not work as expected. If the versions are misaligned, you will see a warning when you import vLLM Omni.

-    If you are seeing strange behavior with the `vllm` command not handling the `--omni` flag correctly, you most likely have a version mismatch with vLLM < `0.28.0` and vLLM Omni `0.28.0`, as vLLM Omni no longer hijacks the vLLM entrypoint. Updating vLLM should resolve this issue.
+    If you are seeing strange behavior with the `vllm` command not handling the `--omni` flag correctly, you most likely have a version mismatch with vLLM < `0.26.0` and vLLM Omni `0.26.0`, as vLLM Omni no longer hijacks the vLLM entrypoint. Updating vLLM should resolve this issue.

 ## Offline Inference

@@ -37,6 +37,7 @@ GENERAL_EXAMPLE_SLUGS = frozenset(
        "text_to_speech",
        "text_to_video",
        "x_to_text",
+        "x_to_video_audio",
    }
 )

@@ -58,6 +58,7 @@ th {
 | `DreamZeroPipeline` | DreamZero-DROID | `GEAR-Dreams/DreamZero-DROID` | ✅︎ | ✅︎ | ✅︎ | ✅︎ | — |
 | `Pi0Pipeline` | π0 (Pi-Zero) VLA | `lerobot/pi0_base` | ✅︎ | | | | [Repository](https://github.com/vllm-project/vllm-omni/blob/main/recipes/lerobot/Pi0.md) |
 | `HeliosPipeline`, `HeliosPyramidPipeline` | Helios | `BestWishYsh/Helios-Base`, `BestWishYsh/Helios-Mid`, `BestWishYsh/Helios-Distilled` | ✅︎ | ✅︎ | ✅︎ | | — |
+| `MagiHumanPipeline` | MagiHuman | `SII-GAIR/daVinci-MagiHuman-Base-1080p` | ✅︎ | ✅︎ | | | — |
 | `OvisImagePipeline` | Ovis-Image | `OvisAI/Ovis-Image` | ✅︎ | ✅︎ | | ✅︎ | — |
 | `LongcatImagePipeline` | LongCat-Image | `meituan-longcat/LongCat-Image` | ✅︎ | ✅︎ | ✅︎ | ✅︎ | — |
 | `LongCatImageEditPipeline` | LongCat-Image-Edit | `meituan-longcat/LongCat-Image-Edit` | ✅︎ | ✅︎ | ✅︎ | ✅︎ | — |
@@ -93,6 +94,7 @@ th {
 | `MiMoV2ASRForCausalLM` | MiMo-V2.5-ASR | `XiaomiMiMo/MiMo-V2.5-ASR` | ✅︎ | ✅︎ | | | — |
 | `Flux2Pipeline` | FLUX.2-dev | `black-forest-labs/FLUX.2-dev` | ✅︎ | ✅︎ | | | — |
 | `FishSpeechSlowARForConditionalGeneration` | Fish Speech S2 Pro | `fishaudio/s2-pro` | ✅︎ | ✅︎ | | ✅︎ | — |
+| `DreamIDOmniPipeline` | DreamID-Omni | `XuGuo699/DreamID-Omni` | ✅︎ | ✅︎ | | | — |
 | `SenseNovaU1Pipeline` | SenseNova-U1 (DiT-only) | `SenseNova/SenseNova-U1-8B-MoT` | ✅︎ | | | | — |
 | `LancePipeline` | Lance | `bytedance-research/Lance` | ✅︎ | | | | — |
 | `HunyuanVideo15Pipeline` | HunyuanVideo-1.5-T2V | `hunyuanvideo-community/HunyuanVideo-1.5-Diffusers-480p_t2v`, `hunyuanvideo-community/HunyuanVideo-1.5-Diffusers-720p_t2v` | ✅︎ | ✅︎ | | | — |
@@ -811,51 +811,6 @@ If you encounter OOM errors:

 Use `/v1/audio/voices` to list available voices for the loaded model.

-## Orchestration Loop (experimental)
-
-Multi-stage omni deployments route stage outputs through a single orchestrator
-loop. By default that loop polls every stage replica on a 1 ms cadence. An
-opt-in event-driven mode replaces the poll with one reader task per live stage
-replica awaiting its client directly, and switches the serving-side
-final-output drain to a condition-variable wakeup at the same time.
-
-**Configuration (environment variables):**
-
-| Variable | Default | Description |
-|----------|---------|-------------|
-| `VLLM_OMNI_EVENT_DRIVEN_ORCH` | `0` (off) | Switches the orchestration loop and the final-output drain from the legacy 1 ms poll to event-driven wakeups. Enabled by `1`, `true`, `yes`, or `on`, matched case-insensitively after surrounding whitespace is stripped; any other value leaves it off. |
-
-Set it on the process that runs the orchestrator (stage 0 of an omni
-deployment) before starting the server:
-
-```bash
-export VLLM_OMNI_EVENT_DRIVEN_ORCH=1
-vllm serve Qwen/Qwen3-TTS-12Hz-1.7B-Base \
-    --omni \
-    --port 8091
-```
-
-The server logs the selected loop mode and its reader/poller counts once at
-startup, so you can confirm which loop is live.
-
-Routing, output ordering, and terminal-state behavior are identical on both
-loops; only the poll cadence changes. Leaving the variable unset keeps the
-legacy poll loop, which is the supported default.
-
-**Known limitations:**
-
- The measured serving A/B (idle CPU 2.43% to 0.07%; TTFP p99 -32% at
-  concurrency 8) predates the rebuild on the per-replica fault-isolation work
-  in [#4285](https://github.com/vllm-project/vllm-omni/pull/4285). That work
-  changed dead-replica handling and reader/poller lifecycle rather than the
-  steady-state output path, and the parity suite covers it, but the serving
-  A/B has not been re-run on the current head.
- The diffusion-poller branch is covered by unit tests only. Deployments whose
-  stages all run as standard engine cores never exercise it, including GLM-TTS,
-  which deploys its DiT without `stage_type: diffusion`.
- Concurrency 1 and 32 measured at parity with the legacy loop. At 32 the
-  latency is admission-bound, which this mode does not address.
-
 ## Development

 Enable debug logging:
@@ -65,7 +65,6 @@ omni = Omni(
 | `--dlo-resident-layers N` | Keep N leading main-DiT blocks on device; requires no-AllGather and model-declared resident paths | `0` |
 | `--host-weight-runtime-mode {disabled,preferred,required}` | HWR policy: no interaction, populate on a miss, or require an exact hit | `disabled` |
 | `--host-weight-runtime-root PATH` | Writable node-local HWR store shared by workers in one storage domain; required for `preferred` and `required` | unset |
-| `--dlo-host-registration-limit-gib N` | Optional per-worker ceiling for registering an HWR mmap; zero adds no ceiling | `0` |

 ## Host-weight loading

@@ -112,12 +111,6 @@ perform a collective and uses the same rank-local transfer behavior.
 HWR is an opt-in startup optimization for models that declare the final-layout
 BF16 restore contract. Use it only with no-AllGather DLO:

-The validated BF16 model contracts currently cover MiniMax H3 and
-`black-forest-labs/FLUX.2-klein-4B`. FLUX.2-klein-9B shares the same model
-class but has not been validated against this contract. FLUX.2-dev, online
-FP8, HSDP, LoRA/adapted weights, and non-default load formats remain outside
-the validated scope.
-
 ```bash
 vllm serve /path/to/model --omni \
  --enable-distributed-layerwise-offload \
@@ -185,48 +178,12 @@ returning to `required`.

 On a cold start, the canonical loader remains authoritative and publishes a
 validated final-layout artifact for later workers. A warm start restores the
-DiT final tensors without ordinary DiT materialization. DLO then attempts to
-register the immutable mapping for direct H2D; if registration is unavailable,
-it streams through the same two bounded host staging slots. The artifact
-identity includes the TP rank/size and SP layout, so TP1, TP2 rank-local shards,
-and distinct SP layouts do not alias one another. Publication failure remains
-separate from a `preferred` serving startup; the next `required` startup
-provides the explicit artifact-availability check.
-
-For local canonical checkpoints, the first eligible worker may hash source
-shards to establish immutable identity. HWR caches those digests in the same
-node-local storage domain and validates file metadata before reuse, so later
-workers normally avoid repeating that read. Cold BF16 publication also hashes
-ordered payloads as they are written and overlaps payload durability work with
-later shards; this changes startup work only, not artifact contents or runtime
-H2D behavior.
-
-#### Registered direct H2D
-
-Registration is attempted automatically only for an eligible warm HWR hit when
-`pin_cpu_memory` is enabled. A successful path is:
-
-```text
-shared read-only HWR mmap -> existing rotating HBM block buffer -> GPU kernel
-```
-
-It removes the recurrent mmap-to-private-staging CPU copy and does not allocate
-the two host staging slots. It does not reduce the H2D payload or make GPU
-kernels access host memory directly.
-
-CUDA requires read-only host-registration capability for the immutable HWR
-mapping. Unsupported capability, a positive registration limit smaller than
-the complete page-aligned mapping, or a safely rolled-back registration error
-falls back to bounded staging. Programmatic configurations can set
-`pin_cpu_memory=False` to disable registration explicitly. A successful
-registration locks the complete mapped range in host memory for that worker's
-lifetime, so use
-`--dlo-host-registration-limit-gib` when an operator-enforced ceiling is
-required.
-
-Shutdown drains H2D work, releases hook/source references, unregisters every
-range, and only then closes the HWR lease. AllGather and direct checkpoint mmap
-retain their existing transfer paths.
+DiT final tensors without ordinary DiT materialization, then DLO streams them
+through the same two bounded host staging slots. The artifact identity includes
+the TP rank/size and SP layout, so TP1, TP2 rank-local shards, and distinct SP
+layouts do not alias one another. Publication failure remains separate from a
+`preferred` serving startup; the next `required` startup provides the explicit
+artifact-availability check.

 When HWR is disabled, DLO is disabled, or AllGather is enabled, the loader does
 not resolve HWR sources or construct its store.
@@ -129,6 +129,7 @@ The following tables show which models support each feature:
 | **Krea 2**               |     ❌     |     ✅      |           ❌           |       ❌        |         ❌         |          ❌          |   ✅    |             ✅             |      ✅ (decode)      |       ❌        |        ❌         |
 | **LongCat-Image**        |     ✅     |     ✅      |           ✅           |       ✅        |         ✅         |          ❌          |   ❌    |             ✅             |          ❌           |       ❌        |        ❌         |
 | **LongCat-Image-Edit**   |     ✅     |     ✅      |           ✅           |       ✅        |         ✅         |          ❌          |   ❌    |             ✅             |          ❌           |       ❌        |        ❌         |
+| **MagiHuman**            |     ❌     |     ❌      |           ❌           |       ❓        |         ✅         |          ❌          |   ❌    |             ✅             |          ❌           |       ❌        |        ❌         |
 | **Nextstep_1(T2I)**      |     ❓     |     ❓      |           ❌           |       ✅        |         ✅         |          ❌          |   ❌    |             ✅             |          ❌           |       ❌        |        ❌         |
 | **OmniGen2**             |     ❌     |     ✅      |           ✅           |       ❌        |         ✅         |          ❌          |   ❌    |             ❌             |          ❌           |       ❌        |        ❌         |
 | **Ovis-Image**           |     ❌     |     ✅      |           ❌           |       ✅        |         ❌         |          ❌          |   ❌    |             ✅             |          ❌           |       ❌        |        ❌         |
@@ -146,7 +147,7 @@ The following tables show which models support each feature:

 > Notes:
 > 1. Nextstep_1(T2I) does not support cache acceleration methods such as TeaCache or Cache-DiT.
-> 2. `Tongyi-MAI/Z-Image-Turbo` is a distilled model with minimal NFEs; CFG-Parallel is not necessary.
+> 2. `Tongyi-MAI/Z-Image-Turbo` and `SII-GAIR/daVinci-MagiHuman-Base-1080p` are distilled models with minimal NFEs; CFG-Parallel is not necessary.
 > 3. Cosmos3 T2I uses `Cosmos3OmniDiffusersPipeline` with `modalities=["image"]`. Model-level CPU offload swaps the nested UND reasoner and GEN generator pathways; layerwise offload remains available for blockwise GEN/UND offload.
 > 4. Krea 2 currently supports single-GPU inference plus LoRA, Cache-DiT, HSDP, CPU/layerwise offload, and VAE-patch-parallel (decode). TP/SP/CFG-Parallel are not yet wired. The few-step distilled (Turbo) checkpoint uses `is_distilled=true` (fixed timestep shift `mu=1.15`); generate at 2048x2048 by default with `num_inference_steps≈8` and `guidance_scale=0`. The Raw checkpoint uses 1024x1024, `num_inference_steps=28`, and `guidance_scale=4.5`.
 > 5. HunyuanImage3 supports step execution. Multi-request step execution requires `TORCH_SDPA`; see [Diffusion Execution Modes](diffusion/execution_modes.md#step-execution).
@@ -164,6 +165,7 @@ The following tables show which models support each feature:
 | **SANA-Video-2B T2V I2V**   |     ❓     |     ❓      |           ❓           |       ❓        |         ❓         |         ❓         |   ❓    |             ❓             |          ❓           |       ❓        |        ❌         |
 | **Helios**                   |     ❌     |     ✅      |           ✅           |       ✅        |         ✅         |         ❌         |   ✅    |             ✅             |          ❌           |       ❌        |        ✅*        |
 | **HunyuanVideo-1.5 T2V I2V** |     ❌     |     ✅      |           ✅           |       ✅        |         ✅         |         ❌         |   ✅    |             ✅             |  ✅ (encode/decode)   |       ✅        |        ❌         |
+| **DreamID-Omni**             |     ❌     |     ❌      |           ❌           |       ✅        |         ❌         |         ❌         |   ✅    |             ✅             |          ❌           |       ❌        |        ❌         |
 | **Cosmos3**                  |     ❌     |     ✅      |           ✅           |       ✅        |         ✅         |         ❌         |   ✅    |             ✅             |  ✅ (encode/decode)   |       ✅        |        ❌         |
 | **LongCat-Video-Avatar-1.5** |     ❌     |     ❌      |           ❌           |       ❌        |         ❌         |         ❌         |   ❌    |             ❌             |          ❌           |       ❌        |        ❌         |
 | **MiniMax-H3**               | ✅ (FL2VA) |     ✅      |           ✅           |       ❌        |       ✅ (DiT/TE)  |         ❌         |   ✅    |             ✅             |       ✅ (tile)       |      ✅ (DiT)      |        ❌         |
@@ -0,0 +1,115 @@
+# X-To-Video-Audio
+
+Source <https://github.com/vllm-project/vllm-omni/tree/main/examples/offline_inference/x_to_video_audio>.
+
+
+The `DreamID-Omni` pipeline generates short videos from text, image and video.
+
+## Local CLI Usage
+### Download the Model locally
+Since DreamID-Omni combine multiple models, and without any config, so we need to download them locally.
+
+```bash
+python download_dreamid_omni.py --output-dir ./dreamid_omni
+```
+After download, the model directory will look like this:
+
+```
+dreamid_omni/
+├── DreamID-Omni/
+│   ├── dreamid_omni.safetensors
+├── MMAudio/
+│   ├── ext_weights/
+│   │   ├── best_netG.pt
+│   │   ├── v1-16.pth
+├── Wan2.2-TI2V-5B/
+│   ├── google/*
+│   ├── models_t5_umt5-xxl-enc-bf16.pth
+│   ├── Wan2.2_VAE.pth
+│
+├── model_index.json # create by download_dreamid_omni.py
+```
+
+### Run the Inference
+```python
+python x_to_video_audio.py \
+  --model /path/to/dreamid_omni \
+  --prompt "Two people walking together and singing happily" \
+  --image-path ./example0.png ./example1.png \
+  --audio-path ./example0.wav ./example1.wav \
+  --video-negative-prompt "jitter, bad hands, blur, distortion" \
+  --audio-negative-prompt "robotic, muffled, echo, distorted" \
+  --cfg-parallel-size 2 \
+  --num-inference-steps 45 \
+  --height 704 \
+  --width 1280 \
+  --output out_dreamid_omni_twoip.mp4
+```
+In the current test scenario (2 images + 2 audio inputs), the VRAM requirement is 72GB, regardless of whether cfg-parallel is enabled or disabled.
+The VRAM usage can be reduced by enabling CPU offload via --enable-cpu-offload.
+For multi-GPU memory reduction on the fused DreamID-Omni transformer, you can also enable HSDP:
+
+```python
+python x_to_video_audio.py \
+  --model /path/to/dreamid_omni \
+  --prompt "Two people walking together and singing happily" \
+  --image-path ./example0.png ./example1.png \
+  --audio-path ./example0.wav ./example1.wav \
+  --video-negative-prompt "jitter, bad hands, blur, distortion" \
+  --audio-negative-prompt "robotic, muffled, echo, distorted" \
+  --cfg-parallel-size 2 \
+  --num-inference-steps 45 \
+  --height 704 \
+  --width 1280 \
+  --use-hsdp \
+  --hsdp-shard-size 2 \
+  --output out_dreamid_omni_twoip.mp4
+```
+
+
+You could take reference images/audios from the test cases in the official repo: https://github.com/Guoxu1233/DreamID-Omni
+
+For example, single IP ref resources can be found under https://github.com/Guoxu1233/DreamID-Omni/tree/main/test_case/oneip, you could download them correspondingly to your local and use them for testing.
+
+```python
+# Example usage for oneip, ref media from the official repo DreamID-Omni
+python x_to_video_audio.py \
+  --model /path/to/dreamid_omni \
+  --prompt "<img1>: In the frame, a woman with black long hair is identified as <sub1>.\n**Overall Environment/Scene**: A lively open-kitchen café at night; stove flames flare, steam rises, and warm pendant lights swing slightly as staff move behind her. The shot is an upper-body close-up.\n**Main Characters/Subjects Appearance**: <sub1> is a young woman with thick dark wavy hair and a side part. She wears a fitted black top under a light apron, a thin gold chain necklace, and small stud earrings.\n**Main Characters/Subjects Actions**: <sub1> tastes the sauce with a spoon, then turns her face toward the camera while still holding the spoon, her expression shifting from focused to conflicted.\n<sub1> maintains eye contact, swallows as if choosing her words, and says, <S>I keep telling myself I’m fine,but some nights it feels like I’m just performing calm.<E>" \
+  --image-path 9.png \
+  --audio-path 9.wav \
+  --video-negative-prompt "jitter, bad hands, blur, distortion" \
+  --audio-negative-prompt "robotic, muffled, echo, distorted" \
+  --cfg-parallel-size 2 \
+  --num-inference-steps 45 \
+  --height 704 \
+  --width 1280 \
+  --output out_dreamid_omni_oneip.mp4
+```
+
+
+Key arguments:
+- `--prompt`: text description (string).
+- `--model`: path to the model local directory.
+- `--height/--width`: output resolution (defaults 704 * 1024).
+- `--image-path`: path to the input image list.
+- `--audio-path`: path to the input audio list, indicate the timbre of the output video.
+- `--cfg-parallel-size`: number of parallel cfg parallel (defaults 1).
+- `--use-hsdp`: enable HSDP weight sharding for DreamID-Omni fused blocks.
+- `--hsdp-shard-size`: number of GPUs used for HSDP sharding.
+- `--hsdp-replicate-size`: number of HSDP replica groups.
+- `--num-inference-steps`: number of denoising steps (defaults 45).
+- `--video-negative-prompt`: negative prompt for video generation.
+- `--audio-negative-prompt`: negative prompt for audio generation.
+- `--enable-cpu-offload`: enable CPU offload (defaults False).
+
+## Example materials
+
+??? abstract "download_dreamid_omni.py"
+    ``````py
+    --8<-- "examples/offline_inference/x_to_video_audio/download_dreamid_omni.py"
+    ``````
+??? abstract "x_to_video_audio.py"
+    ``````py
+    --8<-- "examples/offline_inference/x_to_video_audio/x_to_video_audio.py"
+    ``````
@@ -0,0 +1,193 @@
+# Text-To-Audio
+
+Source <https://github.com/vllm-project/vllm-omni/tree/main/examples/online_serving/stable_audio>.
+
+This example demonstrates how to deploy Stable Audio models for online text-to-audio generation using vLLM-Omni.
+
+## Supported Models
+
+| Model | Description |
+|-------|-------------|
+| `stabilityai/stable-audio-open-1.0` | Open-source audio generation, up to ~47 seconds, 44.1 kHz stereo |
+
+## Start Server
+
+### Basic Start
+
+```bash
+vllm-omni serve stabilityai/stable-audio-open-1.0 \
+    --host 0.0.0.0 \
+    --port 8091 \
+    --gpu-memory-utilization 0.9 \
+    --trust-remote-code \
+    --enforce-eager \
+    --omni
+```
+
+## API Calls
+
+### Method 1: Using curl
+
+```bash
+# Run all curl examples
+bash curl_examples.sh
+
+# Or execute directly
+curl -X POST http://localhost:8091/v1/audio/generate \
+    -H "Content-Type: application/json" \
+    -d '{
+        "input": "The sound of a cat purring",
+        "audio_length": 10.0
+    }' --output cat.wav
+```
+
+### Method 2: Using Python Client
+
+```bash
+cd examples/online_serving/stable_audio
+
+# Simple generation
+python stable_audio_client.py \
+    --text "The sound of a cat purring"
+
+# With custom duration
+python stable_audio_client.py \
+    --text "A dog barking" \
+    --audio_length 5.0
+
+# With all parameters
+python stable_audio_client.py \
+    --text "Thunder and rain" \
+    --audio_length 15.0 \
+    --negative_prompt "Low quality" \
+    --guidance_scale 7.0 \
+    --num_inference_steps 100 \
+    --seed 42 \
+    --output thunder.wav
+```
+
+The Python client supports the following command-line arguments:
+
+- `--api_url`: API endpoint URL (default: `http://localhost:8091/v1/audio/generate`)
+- `--text`: Text prompt for audio generation (default: `"The sound of a cat purring"`)
+- `--audio_length`: Audio length in seconds (default: `10.0`, max ~47s for `stable-audio-open-1.0`)
+- `--audio_start`: Audio start time in seconds (default: `0.0`)
+- `--negative_prompt`: Negative prompt for classifier-free guidance (default: `"Low quality"`)
+- `--guidance_scale`: Guidance scale for diffusion (default: `7.0`)
+- `--num_inference_steps`: Number of inference steps (default: `100`)
+- `--seed`: Random seed for reproducibility (default: `None`)
+- `--response_format`: Audio output format (default: `wav`). Options: `wav`, `mp3`, `flac`, `pcm`
+- `--output`: Output file path (default: `stable_audio_output.wav`)
+
+### Method 3: Using Python httpx
+
+```python
+import httpx
+
+response = httpx.post(
+    "http://localhost:8091/v1/audio/generate",
+    json={
+        "input": "The sound of ocean waves crashing on a beach",
+        "audio_length": 10.0,
+        "negative_prompt": "Low quality, distorted",
+        "guidance_scale": 7.0,
+        "num_inference_steps": 100,
+    },
+    timeout=300.0,
+)
+
+with open("ocean.wav", "wb") as f:
+    f.write(response.content)
+```
+
+## Request Format
+
+### Simple Generation
+
+```json
+{
+    "input": "The sound of ocean waves"
+}
+```
+
+### Generation with Parameters
+
+```json
+{
+    "input": "A piano playing a gentle melody",
+    "audio_length": 10.0,
+    "negative_prompt": "Low quality, distorted, noisy",
+    "guidance_scale": 8.0,
+    "num_inference_steps": 150,
+    "seed": 42,
+    "response_format": "wav"
+}
+```
+
+## API Reference
+
+### Endpoint
+
+```
+POST /v1/audio/generate
+Content-Type: application/json
+```
+
+### Generation Parameters
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `input` | string | **required** | Text prompt describing the audio to generate |
+| `model` | string | server's model | Model to use (optional, should match server if specified) |
+| `response_format` | string | "wav" | Audio format: wav, mp3, flac, pcm, opus |
+| `speed` | float | 1.0 | Playback speed (0.25 - 4.0) |
+| `audio_length` | float | null | Audio duration in seconds (max ~47s for `stable-audio-open-1.0`) |
+| `audio_start` | float | 0.0 | Audio start time in seconds |
+| `negative_prompt` | string | null | Text describing what to avoid in generation |
+| `guidance_scale` | float | model default | Classifier-free guidance scale (higher = more adherence to prompt) |
+| `num_inference_steps` | int | model default | Number of denoising steps (higher = better quality, slower) |
+| `seed` | int | null | Random seed for reproducible generation |
+
+### Response Format
+
+Returns binary audio data with appropriate `Content-Type` header (e.g., `audio/wav`).
+
+## Tuning Tips
+
+1. **Audio Length**: Keep under 47 seconds for `stable-audio-open-1.0`.
+2. **Quality vs Speed**:
+   - 50 steps: Fast, decent quality (quick previews)
+   - 100 steps: Good balance (general purpose)
+   - 150+ steps: High quality, slower (final / critical audio)
+3. **Guidance Scale**:
+   - Lower (3 - 5): More creative / varied output
+   - Default (7): Good balance
+   - Higher (10+): Strict adherence to the prompt
+4. **Negative Prompts**: Use to avoid unwanted characteristics such as `"Low quality"`, `"distorted"`, `"noisy"`.
+5. **Seeds**: Set a fixed seed to get deterministic, reproducible results.
+
+## File Description
+
+| File | Description |
+|------|-------------|
+| `curl_examples.sh` | Curl examples covering common use cases |
+| `stable_audio_client.py` | Python client with full CLI argument support |
+
+## Troubleshooting
+
+1. **Audio generation model did not produce audio output**: Verify the server started successfully and the model loaded without errors.
+2. **Connection refused**: Make sure the server is running on the correct port.
+3. **Generation timeout**: Reduce `num_inference_steps` or `audio_length`, and check GPU memory with `nvidia-smi`.
+4. **Out of memory**: Lower `--gpu-memory-utilization` or reduce `audio_length`.
+5. **Audio quality issues**: Increase `num_inference_steps`, add a negative prompt, or raise `guidance_scale`.
+
+## Example materials
+
+??? abstract "stable_audio_client.py"
+    ``````py
+    --8<-- "examples/online_serving/stable_audio/stable_audio_client.py"
+    ``````
+??? abstract "curl_examples.sh"
+    ``````sh
+    --8<-- "examples/online_serving/stable_audio/curl_examples.sh"
+    ``````
@@ -1,50 +0,0 @@
-# SVDQuant W4A4
-
-## Overview
-
-[SVDQuant](https://arxiv.org/abs/2411.05007) combines four-bit weights
-and activations with a small low-rank branch that corrects part of the
-quantization error. vLLM-Omni consumes an offline-quantized checkpoint;
-it does not calibrate the model while loading.
-
-## Checkpoint contract
-
-Place the following entry in the diffusion transformer's `config.json`:
-
-```json
-{
-  "quantization_config": {
-    "quant_method": "svdquant",
-    "rank": 32,
-    "precision": "nvfp4",
-    "act_unsigned": false,
-    "modules_to_not_convert": []
-  }
-}
-```
-
-For a quantized linear with input size `K`, output size `N`, and correction
-rank `R`, the checkpoint stores:
-
-| Suffix | Shape | dtype |
-| --- | --- | --- |
-| `qweight` | `(N, K / 2)` | `int8` (two packed FP4 values per byte) |
-| `wscales` | `(K / 16, N)` | `float8_e4m3fn` |
-| `proj_down` | `(K, R)` | `bfloat16` |
-| `proj_up` | `(N, R)` | `bfloat16` |
-| `smooth_factor` | `(K,)` | `bfloat16` |
-| `wcscales` | `(N,)` | `bfloat16` |
-| `wtscale` | `(1,)` | `bfloat16` |
-
-`K` must be divisible by 16 on every tensor-parallel rank. Set `wcscales` to
-ones when no per-output correction is needed. Modules listed in
-`modules_to_not_convert` keep their checkpoint precision.
-
-## Runtime support
-
-The compatibility path accepts BF16 inputs and executes an NVFP4 GEMM followed
-by the BF16 rank correction. It supports vLLM's FlashInfer, CUTLASS, and FBGEMM
-NVFP4 tensor layouts; incompatible forced backends fail during model loading.
-SM103 is the currently validated and enabled hardware target. Native fusion of
-the NVFP4 GEMM and rank correction is separate from this checkpoint-loading
-contract.
@@ -1,9 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-"""vLLM-Omni example scripts, importable as a package.
-
-Keep this ``__init__.py``: with the upstream vLLM installed editable (which also
-places an ``examples`` package on ``sys.path``), a regular package at this repo
-root wins over the upstream ``examples`` namespace during ``import examples``.
-"""
@@ -0,0 +1,108 @@
+import argparse
+import fcntl
+import os
+import site
+import subprocess
+import tempfile
+import time
+from pathlib import Path
+
+from huggingface_hub import snapshot_download
+
+DEPENDENCY_REPO = "https://github.com/bytedance/DreamID-V.git"
+DEPENDENCY_BRANCH = "omni"
+CACHE_DIR = Path(tempfile.gettempdir()) / "vllm-omni-dependency"
+LOCK_FILE = CACHE_DIR / ".install.lock"
+DEPENDENCY_DIR = CACHE_DIR / "DreamID-Omni"
+
+
+def download_dependency():
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+    with open(LOCK_FILE, "w") as f:
+        fcntl.flock(f, fcntl.LOCK_EX)
+        if not DEPENDENCY_DIR.exists():
+            print(f"Downloading DreamID-Omni to {DEPENDENCY_DIR} ...")
+            subprocess.run(
+                ["git", "clone", "--depth", "1", DEPENDENCY_REPO, "--branch", DEPENDENCY_BRANCH, str(DEPENDENCY_DIR)],
+                check=True,
+            )
+            print("Download finished.")
+        fcntl.flock(f, fcntl.LOCK_UN)
+
+    # write .pth to site-packages
+    site_packages = Path(site.getsitepackages()[0])
+    pth_file = site_packages / "vllm_omni_dependency.pth"
+    pth_file.write_text(str(DEPENDENCY_DIR))
+    print(f"Added {DEPENDENCY_DIR} to site-packages via {pth_file}")
+
+
+def timed_download(repo_id: str, local_dir: str, allow_patterns: list | None = None):
+    """Download files from HF repo and log time + destination."""
+    if os.path.exists(local_dir):
+        print(f"Directory {local_dir} already exists. Skipping download.")
+        return
+    print(f"Starting download from {repo_id} into {local_dir}")
+    start_time = time.time()
+
+    snapshot_download(
+        repo_id=repo_id,
+        local_dir=local_dir,
+        local_dir_use_symlinks=False,
+        allow_patterns=allow_patterns,
+    )
+
+    elapsed = time.time() - start_time
+    print(f"✅ Finished downloading {repo_id} in {elapsed:.2f} seconds. Files saved at: {local_dir}")
+
+
+def main(output_dir: str):
+    # Wan2.2
+    wan_dir = os.path.join(output_dir, "Wan2.2-TI2V-5B")
+    timed_download(
+        repo_id="Wan-AI/Wan2.2-TI2V-5B",
+        local_dir=wan_dir,
+        allow_patterns=["google/*", "models_t5_umt5-xxl-enc-bf16.pth", "Wan2.2_VAE.pth"],
+    )
+
+    # MMAudio
+    mm_audio_dir = os.path.join(output_dir, "MMAudio")
+    timed_download(
+        repo_id="hkchengrex/MMAudio",
+        local_dir=mm_audio_dir,
+        allow_patterns=["ext_weights/best_netG.pt", "ext_weights/v1-16.pth"],
+    )
+
+    dreamid_dir = os.path.join(output_dir, "DreamID-Omni")
+
+    timed_download(repo_id="XuGuo699/DreamID-Omni", local_dir=dreamid_dir)
+
+    # Now we construct the config file
+    import json
+
+    data = {
+        "_class_name": "DreamIDOmniPipeline",
+    }
+
+    with open(os.path.join(output_dir, "model_index.json"), "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2)
+
+    print(f"model_index.json created at {os.path.join(output_dir, 'model_index.json')}")
+
+    transformer_dir = os.path.join(output_dir, "transformer")
+    os.makedirs(transformer_dir, exist_ok=True)
+    with open(os.path.join(transformer_dir, "config.json"), "w", encoding="utf-8") as f:
+        json.dump({"fusion": "DreamID-Omni/dreamid_omni.safetensors"}, f)
+    print(f"transformer/config.json created at {os.path.join(transformer_dir, 'config.json')}")
+
+    # now we download the dependency code
+    download_dependency()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Download models from Hugging Face")
+    parser.add_argument(
+        "--output-dir", type=str, default="./dreamid_omni", help="Base directory to save downloaded models"
+    )
+    args = parser.parse_args()
+    main(args.output_dir)
@@ -0,0 +1,163 @@
+# X-To-Video-Audio
+
+The `DreamID-Omni` pipeline generates short videos from text, image and video.
+
+## Local CLI Usage
+### Download the Model locally
+Since DreamID-Omni combine multiple models, and without any config, so we need to download them locally.
+
+```bash
+python download_dreamid_omni.py --output-dir ./dreamid_omni
+```
+After download, the model directory will look like this:
+
+```
+dreamid_omni/
+├── DreamID-Omni/
+│   ├── dreamid_omni.safetensors
+├── MMAudio/
+│   ├── ext_weights/
+│   │   ├── best_netG.pt
+│   │   ├── v1-16.pth
+├── Wan2.2-TI2V-5B/
+│   ├── google/*
+│   ├── models_t5_umt5-xxl-enc-bf16.pth
+│   ├── Wan2.2_VAE.pth
+│
+├── model_index.json
+└── transformer/
+    └── config.json   # create by download_dreamid_omni.py
+```
+
+### Run the Inference
+```python
+python x_to_video_audio.py \
+  --model /path/to/dreamid_omni \
+  --prompt "Two people walking together and singing happily" \
+  --image-path ./example0.png ./example1.png \
+  --audio-path ./example0.wav ./example1.wav \
+  --video-negative-prompt "jitter, bad hands, blur, distortion" \
+  --audio-negative-prompt "robotic, muffled, echo, distorted" \
+  --cfg-parallel-size 2 \
+  --num-inference-steps 45 \
+  --height 704 \
+  --width 1280 \
+  --output out_dreamid_omni_twoip.mp4
+```
+In the current test scenario (2 images + 2 audio inputs), the VRAM requirement is 72GB, regardless of whether cfg-parallel is enabled or disabled.
+The VRAM usage can be reduced by enabling CPU offload via --enable-cpu-offload.
+For multi-GPU memory reduction on the fused DreamID-Omni transformer, you can also enable HSDP:
+
+```python
+python x_to_video_audio.py \
+  --model /path/to/dreamid_omni \
+  --prompt "Two people walking together and singing happily" \
+  --image-path ./example0.png ./example1.png \
+  --audio-path ./example0.wav ./example1.wav \
+  --video-negative-prompt "jitter, bad hands, blur, distortion" \
+  --audio-negative-prompt "robotic, muffled, echo, distorted" \
+  --cfg-parallel-size 2 \
+  --num-inference-steps 45 \
+  --height 704 \
+  --width 1280 \
+  --use-hsdp \
+  --hsdp-shard-size 2 \
+  --output out_dreamid_omni_twoip.mp4
+```
+
+
+You could take reference images/audios from the test cases in the official repo: https://github.com/Guoxu1233/DreamID-Omni
+
+For example, single IP ref resources can be found under https://github.com/Guoxu1233/DreamID-Omni/tree/main/test_case/oneip, you could download them correspondingly to your local and use them for testing.
+
+```python
+# Example usage for oneip, ref media from the official repo DreamID-Omni
+python x_to_video_audio.py \
+  --model /path/to/dreamid_omni \
+  --prompt "<img1>: In the frame, a woman with black long hair is identified as <sub1>.\n**Overall Environment/Scene**: A lively open-kitchen café at night; stove flames flare, steam rises, and warm pendant lights swing slightly as staff move behind her. The shot is an upper-body close-up.\n**Main Characters/Subjects Appearance**: <sub1> is a young woman with thick dark wavy hair and a side part. She wears a fitted black top under a light apron, a thin gold chain necklace, and small stud earrings.\n**Main Characters/Subjects Actions**: <sub1> tastes the sauce with a spoon, then turns her face toward the camera while still holding the spoon, her expression shifting from focused to conflicted.\n<sub1> maintains eye contact, swallows as if choosing her words, and says, <S>I keep telling myself I’m fine,but some nights it feels like I’m just performing calm.<E>" \
+  --image-path 9.png \
+  --audio-path 9.wav \
+  --video-negative-prompt "jitter, bad hands, blur, distortion" \
+  --audio-negative-prompt "robotic, muffled, echo, distorted" \
+  --cfg-parallel-size 2 \
+  --num-inference-steps 45 \
+  --height 704 \
+  --width 1280 \
+  --output out_dreamid_omni_oneip.mp4
+```
+
+
+## MagiHuman (`--model-type magi-human`)
+
+MagiHuman is a text → video+audio model with a DiT MoE backbone and a ~9B-param
+T5Gemma text encoder. A detailed text prompt is the only required input; an optional
+image and/or audio file may be supplied for conditioning. Natively supports Tensor
+Parallelism. For an 80GB node, `--tensor-parallel-size 4` is recommended to shard
+the MoE weights and the text encoder.
+
+> Install [MagiCompiler](https://github.com/SandAI-org/MagiCompiler) for correct
+> attention-kernel behaviour (the pipeline otherwise falls back to stubs).
+
+Text-only generation:
+
+```bash
+python x_to_video_audio.py \
+  --model-type magi-human \
+  --model /path/to/daVinci-MagiHuman \
+  --prompt "A young woman with long, wavy golden blonde hair... <dialogue and background sound>" \
+  --tensor-parallel-size 4 \
+  --height 256 --width 448 \
+  --num-inference-steps 8 \
+  --seed 52 \
+  --extra-body '{"seconds": 5, "sr_height": 1080, "sr_width": 1920, "sr_num_inference_steps": 5}' \
+  --output output_magihuman.mp4
+```
+
+With optional image and audio conditioning:
+
+```bash
+python x_to_video_audio.py \
+  --model-type magi-human \
+  --model /path/to/daVinci-MagiHuman \
+  --prompt "A young woman..." \
+  --tensor-parallel-size 4 \
+  --height 256 --width 448 \
+  --num-inference-steps 8 \
+  --seed 52 \
+  --extra-body '{"image_path": "/path/to/ref.jpg", "audio_path": "/path/to/ref.wav", "sr_height": 1080, "sr_width": 1920, "sr_num_inference_steps": 5}' \
+  --output output_magihuman.mp4
+```
+
+MagiHuman-specific arguments are passed as a JSON dict via `--extra-body` (declared
+in `vllm_omni/model_extras/magi_human.py`, routed via `extra_args`):
+
+- `seconds`: output duration in seconds (default 10; ignored when `audio_path` is set,
+  because the audio length then determines the number of frames).
+- `audio_path`: path to an audio file for audio-to-video conditioning. When provided,
+  the audio drives the frame count and is encoded as a latent condition into the DiT
+  (`is_a2v` mode). Omit for pure text-to-video+audio generation.
+- `image_path`: path to an image file for visual conditioning. Applied at both the
+  base-resolution (BR) and super-resolution (SR) stages when SR is enabled.
+- `sr_height` / `sr_width`: super-resolution output resolution. SR stage is skipped
+  when these are omitted.
+- `sr_num_inference_steps`: denoising steps for the SR stage.
+
+## DreamID-Omni arguments
+
+Key arguments:
+- `--prompt`: text description (string).
+- `--model`: path to the model local directory.
+- `--height/--width`: output resolution (defaults 704 * 1024).
+- `--image-path`: path to the input image list.
+- `--audio-path`: path to the input audio list, indicate the timbre of the output video.
+- `--cfg-parallel-size`: number of parallel cfg parallel (defaults 1).
+- `--use-hsdp`: enable HSDP weight sharding for DreamID-Omni fused blocks.
+- `--hsdp-shard-size`: number of GPUs used for HSDP sharding.
+- `--hsdp-replicate-size`: number of HSDP replica groups.
+- `--num-inference-steps`: number of denoising steps (defaults 45).
+- `--video-negative-prompt`: negative prompt for video generation.
+- `--audio-negative-prompt`: negative prompt for audio generation.
+- `--enable-cpu-offload`: enable CPU offload (defaults False).
+- `--cache-backend`: enable `cache_dit` for acceleration.
+- `--quantization`: online (dynamic) quantization method — `fp8` or `int8`.
+  (VAEs, the T5 text encoder, norms and modulation stay bf16.)
@@ -0,0 +1,279 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import argparse
+import json
+import re
+import time
+from typing import Any
+
+import numpy as np
+from PIL import Image
+from vllm.multimodal.media.audio import load_audio
+
+from vllm_omni.diffusion.utils.media_utils import mux_video_audio_bytes
+from vllm_omni.entrypoints.omni import Omni
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".bmp", ".webp", ".gif"}
+AUDIO_EXTENSIONS = {".wav", ".mp3", ".flac", ".m4a", ".aac", ".ogg"}
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Offline inference for X -> video+audio models.")
+    parser.add_argument("--model", required=True, help="Model ckpt root directory.")
+    parser.add_argument(
+        "--model-type",
+        default="dreamid-omni",
+        choices=["dreamid-omni", "magi-human"],
+        help="Model type.",
+    )
+    parser.add_argument("--prompt", default=None, help="Text prompt.")
+
+    parser.add_argument("--image-path", type=str, nargs="+", help="list of image-path")
+    parser.add_argument("--audio-path", type=str, nargs="+", help="list of audio-path")
+    parser.add_argument("--prompt-file", type=str, default=None, help="Text prompt in json format.")
+    parser.add_argument(
+        "--extra-body",
+        type=str,
+        default=None,
+        help="[magi-human] JSON dict of model-specific extra params (declared in vllm_omni/model_extras/), "
+        'merged into sampling extra_args. Example: \'{"image_path": "/path/to/img.jpg", "seconds": 5}\'.',
+    )
+
+    parser.add_argument("--height", type=int, default=704, help="Video height.")
+    parser.add_argument("--width", type=int, default=1280, help="Video width.")
+    parser.add_argument("--num-inference-steps", type=int, default=45, help="Sampling steps.")
+    parser.add_argument("--solver-name", default="unipc", help="Solver name: unipc|dpm++|euler.")
+    parser.add_argument("--shift", type=float, default=5.0, help="Scheduler shift.")
+    parser.add_argument("--seed", type=int, default=103, help="Random seed for reproducible generation.")
+    parser.add_argument(
+        "--cfg-parallel-size",
+        type=int,
+        default=1,
+        choices=[1, 2, 3, 4],
+        help="Number of GPUs used for classifier free guidance parallel size (max 4 branches).",
+    )
+    parser.add_argument(
+        "--tensor-parallel-size",
+        type=int,
+        default=1,
+        help=("Number of GPUs used for tensor parallelism (TP) inside the DiT."),
+    )
+    parser.add_argument(
+        "--video-negative-prompt",
+        default="jitter, bad hands, blur, distortion",
+        help="Negative prompt for video.",
+    )
+    parser.add_argument(
+        "--audio-negative-prompt",
+        default="robotic, muffled, echo, distorted",
+        help="Negative prompt for audio.",
+    )
+    parser.add_argument("--output", default="dreamid_output.mp4", help="Output video path.")
+    parser.add_argument(
+        "--quantization",
+        type=str,
+        default=None,
+        choices=["fp8", "int8"],
+        help=("Online (dynamic) quantization method for the DreamID-Omni transformer. "),
+    )
+    parser.add_argument(
+        "--enable-cpu-offload",
+        action="store_true",
+        default=False,
+        help="Enable CPU offloading for diffusion models.",
+    )
+    parser.add_argument(
+        "--enable-layerwise-offload",
+        action="store_true",
+        help="Enable layerwise (blockwise) offloading on DiT modules.",
+    )
+    parser.add_argument("--cache-backend", type=str, default=None, choices=["cache_dit"], help="Cache backend.")
+    parser.add_argument(
+        "--use-hsdp",
+        action="store_true",
+        help="Enable HSDP for DreamID-Omni fused transformer blocks.",
+    )
+    parser.add_argument(
+        "--hsdp-shard-size",
+        type=int,
+        default=1,
+        help="Number of GPUs used for HSDP sharding when HSDP is enabled.",
+    )
+    parser.add_argument(
+        "--hsdp-replicate-size",
+        type=int,
+        default=1,
+        help="Number of HSDP replica groups. Default 1 means pure sharding.",
+    )
+    return parser.parse_args()
+
+
+def load_image_and_audio(image_paths, audio_paths):
+    image = []
+    audio = []
+
+    for path in image_paths:
+        with Image.open(path) as img:
+            img = img.convert("RGB")
+            image.append(img)
+
+    for path in audio_paths:
+        audio_array, sr = load_audio(path, sr=16000)
+        audio_array = audio_array[int(sr * 1) : int(sr * 3)]
+        audio.append(audio_array)
+    return image, audio
+
+
+def _extract_peak_memory_mb(result: Any) -> float:
+    """Pull worker-reported peak VRAM (MiB) generation result.
+
+    Mirrors vllm_omni/entrypoints/openai/serving_video.py:_extract_peak_memory_mb.
+    """
+    if isinstance(result, list):
+        result = result[0] if result else None
+    if result is None:
+        return 0.0
+    val = getattr(result, "peak_memory_mb", 0.0)
+    if not val:
+        inner = result
+        if isinstance(inner, list):
+            inner = inner[0] if inner else None
+        val = getattr(inner, "peak_memory_mb", 0.0)
+    try:
+        return float(val or 0.0)
+    except (TypeError, ValueError):
+        return 0.0
+
+
+def main() -> None:
+    args = parse_args()
+    if args.prompt is None and args.prompt_file is None:
+        raise ValueError("Either --prompt or --prompt-file must be provided.")
+
+    text_prompt = args.prompt
+    if args.prompt_file:
+        with open(args.prompt_file) as f:
+            text_prompt = json.load(f)
+            text_prompt = re.sub(
+                r"\[SPEAKER_TIMESTAMPS_START\].*?\[SPEAKER_TIMESTAMPS_END\]", "", text_prompt, flags=re.DOTALL
+            ).strip()
+            text_prompt = re.sub(
+                r"\[AUDIO_DESCRIPTION_START].*?\[AUDIO_DESCRIPTION_END]", "", text_prompt, flags=re.DOTALL
+            ).strip()
+            text_prompt = re.sub(r"\[[A-Z_]+\]", "", text_prompt)
+            text_prompt = re.sub(r"\n\s*\n", "\n", text_prompt).strip()
+
+    if args.model_type == "magi-human":
+        prompt = text_prompt
+        extra_args = json.loads(args.extra_body) if args.extra_body else {}
+        sampling_params = OmniDiffusionSamplingParams(
+            height=args.height,
+            width=args.width,
+            num_inference_steps=args.num_inference_steps,
+            seed=args.seed,
+            extra_args=extra_args,
+        )
+    else:
+        image, audio = load_image_and_audio(args.image_path, args.audio_path)
+
+        prompt = {
+            "prompt": text_prompt,
+            "video_negative_prompt": args.video_negative_prompt,
+            "audio_negative_prompt": args.audio_negative_prompt,
+            "multi_modal_data": {"image": image, "audio": audio},
+        }
+
+        sampling_params = OmniDiffusionSamplingParams(
+            height=args.height,
+            width=args.width,
+            num_inference_steps=args.num_inference_steps,
+            seed=args.seed,
+            extra_args={
+                "solver_name": args.solver_name,
+                "shift": args.shift,
+            },
+        )
+
+    cache_config = None
+    if args.cache_backend == "cache_dit":
+        cache_config = {
+            "Fn_compute_blocks": 1,
+            "Bn_compute_blocks": 0,
+            "max_warmup_steps": 4,
+            "max_cached_steps": 20,
+            "residual_diff_threshold": 0.24,
+            "max_continuous_cached_steps": 3,
+            "enable_taylorseer": False,
+            "taylorseer_order": 1,
+            "scm_steps_mask_policy": None,
+            "scm_steps_policy": "dynamic",
+        }
+
+    omni_kwargs = dict(
+        model=args.model,
+        cfg_parallel_size=args.cfg_parallel_size,
+        tensor_parallel_size=args.tensor_parallel_size,
+        use_hsdp=args.use_hsdp,
+        hsdp_shard_size=args.hsdp_shard_size,
+        hsdp_replicate_size=args.hsdp_replicate_size,
+        model_type=args.model_type,
+        enable_cpu_offload=args.enable_cpu_offload,
+        enable_layerwise_offload=args.enable_layerwise_offload,
+        cache_backend=args.cache_backend,
+        cache_config=cache_config,
+    )
+    if args.quantization is not None:
+        omni_kwargs["quantization"] = args.quantization
+    omni = Omni(**omni_kwargs)
+    start = time.perf_counter()
+    outputs = omni.generate(prompt, sampling_params)
+    elapsed = time.perf_counter() - start
+
+    if not outputs:
+        raise RuntimeError("No output returned from the model.")
+    result = outputs[0]
+    if not result.images:
+        raise RuntimeError("No video frames found in model output.")
+    generated_video = result.images[0]
+    mm = result.multimodal_output or {}
+    generated_audio = mm.get("audio")
+
+    if args.model_type == "magi-human":
+        # MagiHuman returns frames already as (F, H, W, C) uint8, ready to mux.
+        fps = float(mm.get("fps", 25))
+        sample_rate = int(mm.get("audio_sample_rate", 24000))
+        frames = generated_video
+    else:
+        fps = float(mm.get("fps", 24))
+        sample_rate = int(mm.get("audio_sample_rate", 16000))
+        # DreamID-Omni returns video as (C, F, H, W) float32 in [-1, 1].
+        # mux_video_audio_bytes expects (F, H, W, C) uint8.
+        if not isinstance(generated_video, np.ndarray) or generated_video.ndim != 4:
+            raise RuntimeError(f"Unexpected video shape: {getattr(generated_video, 'shape', None)}")
+        frames = generated_video.transpose(1, 2, 3, 0)
+        frames = (np.clip((frames + 1.0) / 2.0, 0.0, 1.0) * 255.0).round().astype(np.uint8)
+
+    audio_np = None
+    if generated_audio is not None:
+        audio_np = np.squeeze(np.asarray(generated_audio)).astype(np.float32)
+
+    output_path = args.output
+    video_bytes = mux_video_audio_bytes(
+        frames,
+        audio_np,
+        fps=float(fps),
+        audio_sample_rate=sample_rate,
+    )
+    with open(output_path, "wb") as f:
+        f.write(video_bytes)
+    print(f"Saved generated video to {output_path}")
+    print(f"Total time: {elapsed:.2f}s")
+    peak_mb = _extract_peak_memory_mb(outputs)
+    if peak_mb:
+        print(f"Worker peak GPU memory (reserved): {peak_mb:.2f} MiB ({peak_mb / 1024:.2f} GiB)")
+
+
+if __name__ == "__main__":
+    main()
@@ -32,14 +32,12 @@ GPU 0 (90%) and colocates the Talker (55%) and Code2Wav (35%) on GPU 1. That
 profile admits at most four concurrent sequences per stage.

 | deploy config | GPUs | Notes |
-| --- | --- | --- |
+|---|---|---|
 | `minicpmo_4_5.yaml` (default) | 1 | Memory-constrained compatibility layout. |
 | `minicpmo_4_5_2gpu.yaml` | 2 | Recommended continuous-batching layout; Talker and Code2Wav share GPU 1. |
 | `minicpmo_4_5_3gpu.yaml` | 3 | One GPU per stage. |
 | `minicpmo_4_5_8x4090.yaml` | 8 | Full 8x4090 layout. |
-
-Every profile sets `session_mode: duplex`, so native full-duplex is served
-from the same process as `/v1/chat/completions`.
+| `minicpmo_4_5_duplex.yaml` | 1 | Experimental native full-duplex overlay. |

 The split pipeline preserves native-duplex epoch/turn identity, segment text,
 turn completion, reference voice, and terminal-audio metadata through
@@ -57,8 +55,8 @@ vllm-omni serve openbmb/MiniCPM-o-4_5 \
 ```

 For local ModelScope checkpoints, replace `openbmb/MiniCPM-o-4_5` with the
-checkpoint path. For native full-duplex, connect `/v1/realtime?duplex=1` on
-this same server.
+checkpoint path. To start the experimental native duplex backend, use
+`vllm_omni/deploy/minicpmo_4_5_duplex.yaml`.

 ### Per-stage overrides

@@ -147,7 +145,7 @@ assistant template, so it is not an apples-to-apples accuracy run.

 ## Run the Realtime duplex CLI demo

-After the server is running, stream one WAV through the Realtime
+After the duplex backend is running, stream one WAV through the Realtime
 WebSocket endpoint:

 ```bash
@@ -1,6 +1,3 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
 """Minimal single-input MiniCPM-o 4.5 Realtime duplex demo.

 Run this after starting the duplex server. Strict lifecycle, overlap, and
@@ -22,8 +19,8 @@ if str(REPO_ROOT) not in sys.path:
    sys.path.insert(0, str(REPO_ROOT))

 from vllm_omni.experimental.fullduplex.client import (  # noqa: E402
-    PCM16_BYTES_PER_SAMPLE,  # noqa: F401 - compatibility export
-    PCM16_SAMPLE_RATE,  # noqa: F401 - compatibility export
+    PCM16_BYTES_PER_SAMPLE,
+    PCM16_SAMPLE_RATE,
    RealtimeDuplexClient,
    RealtimeEventCollector,
    build_realtime_url,
@@ -31,13 +28,6 @@ from vllm_omni.experimental.fullduplex.client import (  # noqa: E402
    wait_for,
    write_pcm16_wav,
 )
-from vllm_omni.experimental.fullduplex.client import chunk_period_ms as _chunk_period_ms  # noqa: E402
-from vllm_omni.experimental.fullduplex.client import (  # noqa: E402
-    has_residual_model_unit as _has_residual_model_unit,
-)
-from vllm_omni.experimental.fullduplex.client import (  # noqa: E402
-    reference_audio_data_url as _ref_audio_data_url,
-)


 class _StreamingOutputWriter:
@@ -143,6 +133,25 @@ def _latest_model_decision(
    return decision


+def _chunk_period_ms(events: list[dict[str, object]]) -> int:
+    for event in reversed(events):
+        session = event.get("session")
+        if not isinstance(session, dict):
+            continue
+        capabilities = session.get("capabilities")
+        if not isinstance(capabilities, dict):
+            continue
+        chunk_period_ms = capabilities.get("chunk_period_ms")
+        if isinstance(chunk_period_ms, int) and chunk_period_ms > 0:
+            return chunk_period_ms
+    return 1000
+
+
+def _has_residual_model_unit(pcm16: bytes, *, chunk_period_ms: int) -> bool:
+    unit_bytes = PCM16_SAMPLE_RATE * PCM16_BYTES_PER_SAMPLE * chunk_period_ms // 1000
+    return bool(unit_bytes > 0 and len(pcm16) % unit_bytes)
+
+
 def _response_in_progress(events: list[dict[str, object]]) -> bool:
    return sum(event.get("type") == "response.created" for event in events) > sum(
        event.get("type") == "response.done" for event in events
@@ -159,6 +168,13 @@ def _event_count_after(
    return sum(event.get("type") == event_type for event in events[index + 1 :])


+def _ref_audio_data_url(path: str | None) -> str | None:
+    if path is None:
+        return None
+    ref_path = Path(path).expanduser()
+    return "data:audio/wav;base64," + base64.b64encode(ref_path.read_bytes()).decode("ascii")
+
+
 async def run_demo(args: argparse.Namespace) -> dict[str, object]:
    input_pcm16 = read_pcm16_wav(Path(args.input_wav))
    if not input_pcm16:
@@ -0,0 +1,234 @@
+# Stable Audio Online Serving
+
+Generate audio from text prompts using Stable Audio models via an OpenAI-compatible API endpoint.
+
+## Features
+
+- **OpenAI-compatible API**: Use `/v1/audio/generate` endpoint
+- **Flexible control**: Adjust audio length, guidance scale, inference steps
+- **Quality control**: Use negative prompts to avoid unwanted characteristics
+- **Reproducible**: Set random seed for deterministic generation
+
+## Quick Start
+
+### 1. Start the Server
+
+```bash
+vllm-omni serve stabilityai/stable-audio-open-1.0 \
+    --host 0.0.0.0 \
+    --port 8091 \
+    --gpu-memory-utilization 0.9 \
+    --trust-remote-code \
+    --enforce-eager \
+    --omni
+```
+
+### 2. Generate Audio
+
+#### Using curl
+
+```bash
+curl -X POST http://localhost:8091/v1/audio/generate \
+    -H "Content-Type: application/json" \
+    -d '{
+        "input": "The sound of a cat purring",
+        "audio_length": 10.0
+    }' --output cat.wav
+```
+
+#### Using Python Client
+
+```bash
+python stable_audio_client.py \
+    --text "The sound of a cat purring" \
+    --audio_length 10.0 \
+    --output cat.wav
+```
+
+#### Using Bash Script
+
+```bash
+bash curl_examples.sh
+```
+
+## API Reference
+
+### Endpoint
+
+```
+POST /v1/audio/generate
+```
+
+### Request Body
+
+```json
+{
+    "input": "Text description of the audio",
+    "audio_length": 10.0,
+    "audio_start": 0.0,
+    "negative_prompt": "Low quality",
+    "guidance_scale": 7.0,
+    "num_inference_steps": 100,
+    "seed": 42,
+    "response_format": "wav"
+}
+```
+
+### Parameters
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `input` | string | **required** | Text prompt describing the audio to generate |
+| `audio_length` | float | ~47s | Audio duration in seconds (max ~47s for stable-audio-open-1.0) |
+| `audio_start` | float | 0.0 | Audio start time in seconds |
+| `negative_prompt` | string | null | Text describing what to avoid in generation |
+| `guidance_scale` | float | 7.0 | Classifier-free guidance scale (higher = more adherence to prompt) |
+| `num_inference_steps` | int | 50 | Number of denoising steps (higher = better quality, slower) |
+| `seed` | int | null | Random seed for reproducibility |
+| `response_format` | string | "wav" | Output format: wav, mp3, flac, pcm |
+
+### Response
+
+Returns audio data in the requested format (default: WAV).
+
+## Usage Examples
+
+### Basic Generation
+
+```bash
+curl -X POST http://localhost:8091/v1/audio/generate \
+    -H "Content-Type: application/json" \
+    -d '{
+        "input": "The sound of ocean waves"
+    }' --output ocean.wav
+```
+
+### Custom Duration
+
+```bash
+curl -X POST http://localhost:8091/v1/audio/generate \
+    -H "Content-Type: application/json" \
+    -d '{
+        "input": "A dog barking",
+        "audio_length": 5.0
+    }' --output dog_5s.wav
+```
+
+### High Quality with Negative Prompt
+
+```bash
+curl -X POST http://localhost:8091/v1/audio/generate \
+    -H "Content-Type: application/json" \
+    -d '{
+        "input": "A piano playing a gentle melody",
+        "audio_length": 10.0,
+        "negative_prompt": "Low quality, distorted, noisy",
+        "guidance_scale": 8.0,
+        "num_inference_steps": 150
+    }' --output piano_hq.wav
+```
+
+### Reproducible Generation
+
+```bash
+curl -X POST http://localhost:8091/v1/audio/generate \
+    -H "Content-Type: application/json" \
+    -d '{
+        "input": "Thunder and rain sounds",
+        "audio_length": 15.0,
+        "seed": 42
+    }' --output thunder.wav
+```
+
+### Quick Generation (Fewer Steps)
+
+For faster generation with slightly lower quality:
+
+```bash
+curl -X POST http://localhost:8091/v1/audio/generate \
+    -H "Content-Type: application/json" \
+    -d '{
+        "input": "Birds chirping in a forest",
+        "audio_length": 8.0,
+        "num_inference_steps": 50
+    }' --output birds_quick.wav
+```
+
+## Python Client Examples
+
+### Simple Generation
+
+```bash
+python stable_audio_client.py \
+    --text "The sound of a cat purring"
+```
+
+### Custom Parameters
+
+```bash
+python stable_audio_client.py \
+    --text "Thunder and rain" \
+    --audio_length 15.0 \
+    --negative_prompt "Low quality" \
+    --guidance_scale 7.0 \
+    --num_inference_steps 100 \
+    --seed 42 \
+    --output thunder.wav
+```
+
+### Different Output Format
+
+```bash
+python stable_audio_client.py \
+    --text "Guitar playing" \
+    --response_format mp3 \
+    --output guitar.mp3
+```
+
+## Tips
+
+1. **Audio Length**: Keep under 47 seconds for `stable-audio-open-1.0`
+2. **Quality vs Speed**:
+   - 50 steps: Fast, decent quality
+   - 100 steps: Good balance (default)
+   - 150+ steps: High quality, slower
+3. **Guidance Scale**:
+   - Lower (3-5): More creative/varied
+   - Default (7): Good balance
+   - Higher (10+): More literal to prompt
+4. **Negative Prompts**: Use to avoid "Low quality", "distorted", "noisy", etc.
+5. **Seeds**: Use same seed for reproducible results
+
+## Performance
+
+| Inference Steps | Quality | Speed | Use Case |
+|----------------|---------|-------|----------|
+| 50 | Good | Fast | Quick previews |
+| 100 (default) | Very Good | Medium | Production |
+| 150+ | Excellent | Slow | Final/critical audio |
+
+## Troubleshooting
+
+### Server not responding
+- Check if server is running: `curl http://localhost:8091/health`
+- Check server logs for errors
+
+### Audio quality issues
+- Increase `num_inference_steps` (e.g., 150)
+- Add negative prompts: `"Low quality, distorted, noisy"`
+- Increase `guidance_scale` for more prompt adherence
+
+### Generation timeout
+- Reduce `num_inference_steps`
+- Reduce `audio_length`
+- Check GPU memory with `nvidia-smi`
+
+### Wrong audio length
+- Ensure `audio_length` is within model limits (~47s max)
+- Adjust `audio_start` if trimming is needed
+
+## See Also
+
+- [Offline Inference Example](../../offline_inference/text_to_audio/README.md)
+- [Stable Audio Model Card](https://huggingface.co/stabilityai/stable-audio-open-1.0)
+- [vLLM-Omni Documentation](https://github.com/vllm-project/vllm-omni)
@@ -0,0 +1,54 @@
+#!/bin/bash
+# Examples for using Stable Audio with curl via /v1/audio/generate endpoint
+
+# Example 1: Simple request with default parameters
+echo "Example 1: Simple request with default parameters"
+curl -X POST http://localhost:8091/v1/audio/generate \
+    -H "Content-Type: application/json" \
+    -d '{
+        "input": "The sound audience clapping and cheering in a stadium"
+    }' --output stadium.wav
+
+# Example 2: Request with custom audio_length
+echo "Example 2: Custom audio length (5 seconds)"
+curl -X POST http://localhost:8091/v1/audio/generate \
+    -H "Content-Type: application/json" \
+    -d '{
+        "input": "The sound of a dog barking",
+        "audio_length": 5.0
+    }' --output dog_5s.wav
+
+# Example 3: Request with negative prompt for quality control
+echo "Example 3: With negative prompt"
+curl -X POST http://localhost:8091/v1/audio/generate \
+    -H "Content-Type: application/json" \
+    -d '{
+        "input": "A piano playing a gentle melody",
+        "audio_length": 10.0,
+        "negative_prompt": "Low quality, distorted, noisy"
+    }' --output piano.wav
+
+# Example 4: Full control with all parameters
+echo "Example 4: Full control (custom length, guidance, steps, seed)"
+curl -X POST http://localhost:8091/v1/audio/generate \
+    -H "Content-Type: application/json" \
+    -d '{
+        "input": "Thunder and rain sounds",
+        "audio_length": 15.0,
+        "negative_prompt": "Low quality",
+        "guidance_scale": 7.0,
+        "num_inference_steps": 100,
+        "seed": 42
+    }' --output thunder_rain.wav
+
+# Example 5: Quick generation with fewer steps (faster but lower quality)
+echo "Example 5: Quick generation (fewer steps)"
+curl -X POST http://localhost:8091/v1/audio/generate \
+    -H "Content-Type: application/json" \
+    -d '{
+        "input": "Ocean waves crashing on a beach",
+        "audio_length": 8.0,
+        "num_inference_steps": 50
+    }' --output ocean.wav
+
+echo "All examples completed!"
@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""
+OpenAI-compatible client for Stable Audio via /v1/audio/generate endpoint.
+
+This script demonstrates how to use the OpenAI-compatible speech API
+to generate audio from text using Stable Audio models.
+
+Examples:
+    # Simple generation
+    python stable_audio_client.py --text "The sound of a cat purring"
+
+    # With custom duration
+    python stable_audio_client.py --text "A dog barking" --audio_length 5.0
+
+    # With all parameters
+    python stable_audio_client.py --text "Thunder and rain" \
+        --audio_length 15.0 \
+        --negative_prompt "Low quality" \
+        --guidance_scale 7.0 \
+        --num_inference_steps 100 \
+        --seed 42 \
+        --output thunder.wav
+"""
+
+import argparse
+import sys
+
+import requests
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Generate audio with Stable Audio via OpenAI-compatible API")
+    parser.add_argument(
+        "--api_url",
+        default="http://localhost:8091/v1/audio/generate",
+        help="API endpoint URL",
+    )
+    parser.add_argument(
+        "--text",
+        default="The sound of a cat purring",
+        help="Text prompt for audio generation",
+    )
+    parser.add_argument(
+        "--audio_length",
+        type=float,
+        default=10.0,
+        help="Audio length in seconds (max ~47s for stable-audio-open-1.0)",
+    )
+    parser.add_argument(
+        "--audio_start",
+        type=float,
+        default=0.0,
+        help="Audio start time in seconds",
+    )
+    parser.add_argument(
+        "--negative_prompt",
+        default="Low quality",
+        help="Negative prompt for classifier-free guidance",
+    )
+    parser.add_argument(
+        "--guidance_scale",
+        type=float,
+        default=7.0,
+        help="Guidance scale for diffusion (higher = more adherence to prompt)",
+    )
+    parser.add_argument(
+        "--num_inference_steps",
+        type=int,
+        default=100,
+        help="Number of inference steps (higher = better quality, slower)",
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=None,
+        help="Random seed for reproducibility",
+    )
+    parser.add_argument(
+        "--output",
+        default="stable_audio_output.wav",
+        help="Output file path",
+    )
+    parser.add_argument(
+        "--response_format",
+        default="wav",
+        choices=["wav", "mp3", "flac", "pcm"],
+        help="Audio output format",
+    )
+    return parser.parse_args()
+
+
+def generate_audio(args):
+    """Generate audio using the API."""
+
+    # Build request payload
+    payload = {
+        "input": args.text,
+        "audio_length": args.audio_length,
+        "audio_start": args.audio_start,
+        "response_format": args.response_format,
+    }
+
+    # Add optional parameters
+    if args.negative_prompt:
+        payload["negative_prompt"] = args.negative_prompt
+    if args.guidance_scale:
+        payload["guidance_scale"] = args.guidance_scale
+    if args.num_inference_steps:
+        payload["num_inference_steps"] = args.num_inference_steps
+    if args.seed is not None:
+        payload["seed"] = args.seed
+
+    print(f"\n{'=' * 60}")
+    print("Stable Audio - Text-to-Audio Generation")
+    print(f"{'=' * 60}")
+    print(f"API URL: {args.api_url}")
+    print(f"Prompt: {args.text}")
+    print(f"Audio length: {args.audio_length}s")
+    print(f"Negative prompt: {args.negative_prompt}")
+    print(f"Guidance scale: {args.guidance_scale}")
+    print(f"Inference steps: {args.num_inference_steps}")
+    if args.seed is not None:
+        print(f"Seed: {args.seed}")
+    print(f"Output: {args.output}")
+    print(f"{'=' * 60}\n")
+
+    try:
+        # Make the API request
+        print("Generating audio...")
+        response = requests.post(
+            args.api_url,
+            json=payload,
+            headers={"Content-Type": "application/json"},
+            timeout=300,  # 5 minute timeout for long generations
+        )
+
+        # Check for errors
+        if response.status_code != 200:
+            print(f"Error: API returned status code {response.status_code}")
+            print(f"Response: {response.text}")
+            return False
+
+        # Save the audio
+        with open(args.output, "wb") as f:
+            f.write(response.content)
+
+        print(f"✓ Audio saved to {args.output}")
+        print(f"  File size: {len(response.content) / 1024:.1f} KB")
+        return True
+
+    except requests.exceptions.Timeout:
+        print("Error: Request timed out. Try reducing inference steps or audio length.")
+        return False
+    except requests.exceptions.ConnectionError:
+        print(f"Error: Could not connect to {args.api_url}")
+        print("Make sure the server is running.")
+        return False
+    except Exception as e:
+        print(f"Error: {e}")
+        return False
+
+
+def main():
+    args = parse_args()
+    success = generate_audio(args)
+    sys.exit(0 if success else 1)
+
+
+if __name__ == "__main__":
+    main()
@@ -839,7 +839,7 @@ hf download lightx2v/Minimax-h3-Turbo "${TURBO_FILE}" --local-dir "${TURBO_DIR}"
 export TURBO_LORA="${TURBO_DIR}/${TURBO_FILE}"
 ```

-Start from a non-offloaded or DLO FL2VA server command and add
+Start from a non-offloaded FL2VA server command and add
 `--task-type fl2va --lora-backend peft --lora-path "${TURBO_LORA}"`.
 `--lora-path` preloads the adapter; each request still activates it and uses
 the published sampling settings:
@@ -853,10 +853,9 @@ the published sampling settings:

 For FL2VA, change `task` and add `input_reference` as shown above. The 8-step,
 ComfyUI, Ref2VA, and v1.1 artifacts are not supported. This integration is
-dynamic-only and does not support prefusion or LoRA composition. DLO is
-supported by keeping the request-switchable LoRA A/B buffers resident on the
-accelerator while DLO streams only the base blocks; budget for this additional
-fixed HBM usage. Model-level and standard layerwise offload remain unsupported.
+dynamic-only and does not support prefusion, DLO, or LoRA composition.
+It also rejects model-level, layerwise, and distributed layerwise offload;
+the legacy dynamic LoRA tensors do not participate in those weight lifecycles.
 The five requested sigma points produce the four denoiser evaluations expected
 by the Turbo artifact.

@@ -1,7 +1,7 @@
 # NemotronLabs VoiceChat 11B

-> Speech-to-speech on a 3-stage vLLM-Omni pipeline: offline single-turn
-> inference and experimental model-native, frame-locked Realtime serving.
+> Offline speech-to-speech: a 16 kHz user utterance in, the agent's spoken reply
+> (text + 22.05 kHz WAV) out, on a 3-stage vLLM-Omni pipeline.

 ## Summary

@@ -11,8 +11,8 @@
  timeline: a Conformer + NemotronH hybrid-Mamba thinker emits one text token
  per acoustic frame, a Gemma3-1B EAR-TTS talker turns the text timeline into
  31-quantizer RVQ code stacks, and an RVQ-VAE codec decodes them to audio.
- Mode: Offline single-turn inference (batch=1), plus experimental native
-  duplex Realtime serving at one 80 ms microphone frame per scheduler wake.
+- Mode: Offline single-turn inference (batch=1). Online/duplex serving,
+  function calling, and batch>1 are documented follow-ups.
 - Maintainer: [`@yuekaizhang`](https://github.com/yuekaizhang)

 ## When to use this recipe
@@ -33,11 +33,6 @@ NeMo modules (`nemo_vendored/`), so no `nemo_toolkit` install is needed.
  [`vllm_omni/model_executor/models/nemotron_voicechat/`](../../vllm_omni/model_executor/models/nemotron_voicechat/)
 - Staged pipeline config:
  [`vllm_omni/deploy/nemotron_labs_voicechat.yaml`](../../vllm_omni/deploy/nemotron_labs_voicechat.yaml)
- Native duplex config and E2E probe:
-  [`vllm_omni/deploy/nemotron_labs_voicechat_duplex.yaml`](../../vllm_omni/deploy/nemotron_labs_voicechat_duplex.yaml),
-  [`tests/e2e/online_serving/nemotron_voicechat_realtime_duplex.py`](../../tests/e2e/online_serving/nemotron_voicechat_realtime_duplex.py)
- Nightly model-level gate:
-  [`tests/e2e/online_serving/test_nemotron_voicechat_duplex.py`](../../tests/e2e/online_serving/test_nemotron_voicechat_duplex.py)
 - Upstream model card:
  [`nvidia/NVIDIA-NemotronLabs-VoiceChat-11B`](https://huggingface.co/nvidia/NVIDIA-NemotronLabs-VoiceChat-11B)
 - Reference implementation: NVIDIA-NeMo/Speech, branch `nemotron-labs-voicechat`
@@ -65,7 +60,7 @@ output stayed within one word of the reference in testing.

 - OS: Linux
 - Python: 3.12
- vLLM version: 0.27.0
+- vLLM version: 0.26.0
 - vLLM-Omni version or commit: this PR / current `main`

 #### Command
@@ -93,55 +88,6 @@ The reply text should read as a coherent spoken-style answer to the question in
 the input WAV, and the WAV should transcribe to (approximately) the same text
 with any ASR model.

-#### Native duplex serving
-
-The checkpoint does not contain the underlying Nemotron text tokenizer. Set
-`NEMOTRON_VOICECHAT_LLM_PATH` to a local snapshot of
-`nvidia/NVIDIA-Nemotron-Nano-9B-v2` before starting an offline deployment.
-
-```bash
-export HF_HUB_OFFLINE=1
-export TRANSFORMERS_OFFLINE=1
-export NEMOTRON_VOICECHAT_LLM_PATH=/path/to/NVIDIA-Nemotron-Nano-9B-v2
-
-vllm-omni serve /path/to/NVIDIA-NemotronLabs-VoiceChat-11B \
-  --omni \
-  --served-model-name nemotron-voicechat \
-  --deploy-config vllm_omni/deploy/nemotron_labs_voicechat_duplex.yaml
-```
-
-The single-GPU profile runs three eager fp32 engine processes on one device.
-
-In another shell, stream only the user channel of one of NVIDIA's bundled
-stereo conversation fixtures:
-
-```bash
-python tests/e2e/online_serving/nemotron_voicechat_realtime_duplex.py \
-  --model nemotron-voicechat \
-  --input-wav /path/to/NVIDIA-NemotronLabs-VoiceChat-11B/turn_taking.wav \
-  --input-channel 0 \
-  --output-dir results/nemotron_voicechat_duplex \
-  --timeout-s 600
-```
-
-The probe requires a completed response, non-silent 22.05 kHz output, and the
-advertised native 80 ms append capabilities. Add `--expect-function-call` and
-use `tool_call.wav` to validate the function-call channel. To validate the
-Realtime tool round trip, also provide the expected arguments and return a
-tool result:
-
-```bash
-python tests/e2e/online_serving/nemotron_voicechat_realtime_duplex.py \
-  --model nemotron-voicechat \
-  --input-wav /path/to/NVIDIA-NemotronLabs-VoiceChat-11B/tool_call.wav \
-  --output-dir results/nemotron_voicechat_tool_call \
-  --expect-function-call \
-  --expected-function-name generate_random_number \
-  --expected-function-arguments '{"min":1,"max":50}' \
-  --function-output 20 \
-  --expected-post-tool-text "random number"
-```
-
 #### Notes

 - Memory usage: the shipped yaml runs all three stages on one GPU
@@ -163,14 +109,5 @@ python tests/e2e/online_serving/nemotron_voicechat_realtime_duplex.py \
  instead of pausing.
 - The talker's `max_tokens` is 16383 (its stage prompt is one placeholder
  token, and the stage context is 16384).
- The 80 ms frame period is a model/protocol contract, not a throughput
-  guarantee. In an eager fp32 H200 profile, Stage 2 emitted 80 ms packets at
-  roughly 0.87--0.88 s intervals (RTF about 10.8--10.9); placing the three
-  stages on separate GPUs did not remove the serial 8-step EAR-TTS bottleneck.
-  The current native duplex path is functionally streaming but not wall-clock
-  realtime.
- Known limitations: batch=1 only. The native duplex deployment allows one
-  active session and does not support barge-in. Tool execution remains
-  client-owned: the server emits function-call events, accepts a validated
-  `function_call_output`, and resumes the live model with the returned result;
-  it does not execute arbitrary tools itself.
+- Known limitations: batch=1 only; offline single turn (no online/duplex
+  serving yet); the function-call channel is decoded but not yet acted on.
@@ -85,9 +85,8 @@ recipes/
 | [`Wan-AI/Wan2.2-I2V.md`](./Wan-AI/Wan2.2-I2V.md) | Image-to-video serving (Wan2.2 14B) | 8x Ascend NPU (A2/A3) |
 | [`Wan-AI/Wan2.2-S2V.md`](./Wan-AI/Wan2.2-S2V.md) | Speech-to-video serving (Wan2.2 14B) | 2x A100/H100 80GB |
 | [`Wan-AI/Wan2.1-VACE.md`](./Wan-AI/Wan2.1-VACE.md) | Unified T2V, I2V, V2LF, FLF2V, inpaint, and R2V | 1x RTX 5090 (1.3B) / 1x L40S 48GB with layerwise offload (14B) |
-| [`XiaomiMiMo/MiMo-Audio.md`](./XiaomiMiMo/MiMo-Audio.md) | Offline + online omni audio (TTS, ASR, dialogue) | 1x RTX 5090 / 5090D 32GB |
 | [`StabilityAI/Stable-Diffusion-3.5.md`](./StabilityAI/Stable-Diffusion-3.5.md) | Text-to-image serving (SD 3.5-medium and SD 3.5-large) | 1x RTX A6000 48GB |
-| [`zai-org/GLM-TTS.md`](./zai-org/GLM-TTS.md) | Online serving for Chinese/English zero-shot voice-cloned TTS | 1x A40 48GB / 2x non-standard RTX 4090 48GB (49,140 MiB each) |
+| [`zai-org/GLM-TTS.md`](./zai-org/GLM-TTS.md) | Online serving for Chinese/English zero-shot voice-cloned TTS | 1x A40 48GB |
 | [`GLM/GLM-Image.md`](./GLM/GLM-Image.md) | Online serving for image generation | 1x A800 80GB / 2x A800 80GB |
 | [`JD/JoyAI-VL-Interaction.md`](./JD/JoyAI-VL-Interaction.md) | Real-time streaming video-language interaction (proactive speak/silence/delegate) | 1x GPU 24GB+ |

@@ -23,6 +23,8 @@ offline validation sample with TeaCache and online serving through the
 - Model: <https://huggingface.co/stabilityai/stable-audio-open-1.0>
 - Offline example:
  [`examples/offline_inference/text_to_audio`](../../examples/offline_inference/text_to_audio)
+- Online example:
+  [`examples/online_serving/stable_audio`](../../examples/online_serving/stable_audio)
 - Audio generation API:
  [`docs/serving/audio_generate_api.md`](../../docs/serving/audio_generate_api.md)
 - Related issue:
@@ -101,7 +103,7 @@ curl -X POST http://localhost:8091/v1/audio/generate \
    "seed": 42,
    "response_format": "wav"
  }' \
-  --output piano_10s.wav
+  --output examples/online_serving/stable_audio/piano_10s.wav
 ```

 ##### Verification
@@ -135,12 +137,12 @@ PY
 Validate the online output:

 ```bash
-ls -lh piano_10s.wav
+ls -lh examples/online_serving/stable_audio/piano_10s.wav

 python - <<'PY'
 import soundfile as sf

-path = "piano_10s.wav"
+path = "examples/online_serving/stable_audio/piano_10s.wav"
 audio, sample_rate = sf.read(path)
 print("sample_rate:", sample_rate)
 print("shape:", audio.shape)
@@ -1,161 +0,0 @@
-# MiMo-Audio for omni audio generation and understanding
-
-> Offline + online TTS, ASR, audio understanding, and multi-turn dialogue
-
-## Summary
-
- Vendor: Xiaomi MiMo
- Model: `XiaomiMiMo/MiMo-Audio-7B-Instruct`
- Task: Text-to-speech, speech-to-text, audio understanding, spoken dialogue
- Mode: Offline end-to-end scripts and online OpenAI-compatible chat serving
- Maintainer: Community
-
-## When to use this recipe
-
-Use this recipe when you want a known-good starting point for running
-MiMo-Audio on a single **32 GB Blackwell consumer GPU** (RTX 5090 / 5090D).
-The bundled deploy profile [`vllm_omni/deploy/mimo_audio_5090d.yaml`](../../vllm_omni/deploy/mimo_audio_5090d.yaml)
-splits VRAM between the AR thinker (stage 0) and code2wav (stage 1), avoids
-FlashAttention-2 on SM 12.x, and keeps the audio tokenizer on CPU to reduce
-Stage-1 GPU pressure.
-
-## References
-
- Upstream model card: <https://huggingface.co/XiaomiMiMo/MiMo-Audio-7B-Instruct>
- Audio tokenizer: <https://huggingface.co/XiaomiMiMo/MiMo-Audio-Tokenizer>
- Offline example:
-  [`examples/offline_inference/mimo_audio/end2end.py`](../../examples/offline_inference/mimo_audio/end2end.py)
- Online example:
-  [`examples/online_serving/mimo_audio/README.md`](../../examples/online_serving/mimo_audio/README.md)
- Default deploy config (generic single GPU):
-  [`vllm_omni/deploy/mimo_audio.yaml`](../../vllm_omni/deploy/mimo_audio.yaml)
- 5090D-tuned deploy config:
-  [`vllm_omni/deploy/mimo_audio_5090d.yaml`](../../vllm_omni/deploy/mimo_audio_5090d.yaml)
- Pipeline / deploy docs:
-  [Stage configs](https://docs.vllm.ai/projects/vllm-omni/en/latest/configuration/stage_configs/)
- Related issue or discussion:
-  [RFC: add recipes folder](https://github.com/vllm-project/vllm-omni/issues/2645)
- Tokenizer device alignment fix (required for CPU tokenizer on stage 1):
-  [PR #6539](https://github.com/vllm-project/vllm-omni/pull/6539)
-
-## Hardware Support
-
-## GPU
-
-### 1x NVIDIA GeForce RTX 5090 / 5090D 32GB
-
-Two-stage async-chunk pipeline (thinker + code2wav) on a single GPU. Tested
-offline with `tts_sft`.
-
-#### Environment
-
- OS: Ubuntu (Linux x86_64)
- Python: 3.12
- PyTorch: 2.11.0+cu129
- Driver / runtime: NVIDIA driver 570.x, CUDA 12.9 runtime (Blackwell SM 12.x)
- GPU: NVIDIA GeForce RTX 5090 D, 32 GB
- vLLM: 0.26.0+cu129
- vLLM-Omni: `main` (tested while [#6539](https://github.com/vllm-project/vllm-omni/pull/6539) was open for CPU-tokenizer support)
-
-Install vLLM-Omni from source and align the vLLM wheel with your CUDA stack.
-On Blackwell, prefer the **cu129** vLLM build over cu13 defaults when using
-PyTorch 2.11+cu129.
-
-Download or cache:
-
- `XiaomiMiMo/MiMo-Audio-7B-Instruct`
- `XiaomiMiMo/MiMo-Audio-Tokenizer` (or a local checkout of the tokenizer repo)
-
-Export the runtime knobs below before offline or online runs:
-
-```bash
-export MIMO_AUDIO_TOKENIZER_PATH="${MIMO_AUDIO_TOKENIZER_PATH:-XiaomiMiMo/MiMo-Audio-Tokenizer}"
-export MIMO_AUDIO_TOKENIZER_DEVICE=cpu
-export MIMO_AUDIO_TOKENIZER_CUDA_GRAPH=0
-export VLLM_USE_FLASHINFER_SAMPLER=0
-export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
-```
-
-Optional (mirror / download stability):
-
-```bash
-export HF_HUB_DISABLE_XET=1
-export HF_ENDPOINT=https://hf-mirror.com   # if you use a Hugging Face mirror
-```
-
-Do **not** set `VLLM_ATTENTION_BACKEND` on vLLM 0.26.x; configure
-`attention_backend: TRITON_ATTN` in the deploy YAML instead.
-
-#### Command
-
-Offline TTS validation from the repository root:
-
-```bash
-cd examples/offline_inference/mimo_audio
-
-python3 -u end2end.py \
-  --deploy-config vllm_omni/deploy/mimo_audio_5090d.yaml \
-  --model-name XiaomiMiMo/MiMo-Audio-7B-Instruct \
-  --query-type tts_sft \
-  --text "The weather is so nice today."
-```
-
-Online serving (requires MiMo chat template):
-
-```bash
-export MIMO_AUDIO_TOKENIZER_PATH="XiaomiMiMo/MiMo-Audio-Tokenizer"
-
-vllm serve XiaomiMiMo/MiMo-Audio-7B-Instruct --omni \
-  --deploy-config vllm_omni/deploy/mimo_audio_5090d.yaml \
-  --served-model-name "MiMo-Audio-7B-Instruct" \
-  --port 18091 \
-  --chat-template ./examples/online_serving/mimo_audio/chat_template.jinja
-```
-
-Pass the same environment exports to the server process when using a CPU
-tokenizer or disabling FlashInfer sampling.
-
-#### Verification
-
-Offline:
-
-```bash
-ls -lh output_audio/tts_sft/*.wav
-```
-
-Expect a non-empty `.wav` under `output_audio/tts_sft/` and a companion `.txt`
-with the decoded text. A successful run completes both stages without a
-Stage-1 `decode_vq` device mismatch.
-
-Online:
-
-```bash
-curl -s -o /tmp/mimo_health.txt -w '%{http_code}' http://127.0.0.1:18091/health
-```
-
-Then use the client under
-[`examples/online_serving/mimo_audio/`](../../examples/online_serving/mimo_audio/).
-
-#### Notes
-
- Memory usage (observed offline): Stage-0 weights ~16.6 GiB; KV cache ~4.9 GiB
-  with `gpu_memory_utilization: 0.78` on stage 0 and `0.12` on stage 1.
- Key flags:
-  - `--deploy-config vllm_omni/deploy/mimo_audio_5090d.yaml` for 5090D memory
-    and `TRITON_ATTN`.
-  - `MIMO_AUDIO_TOKENIZER_PATH` is mandatory.
-  - `MIMO_AUDIO_TOKENIZER_DEVICE=cpu` saves VRAM; requires
-    [#6539](https://github.com/vllm-project/vllm-omni/pull/6539) (or equivalent
-    fix) so code2wav decode uses the tokenizer device.
-  - `VLLM_USE_FLASHINFER_SAMPLER=0` avoids FlashInfer top-p/top-k sampler
-    issues on consumer GPUs.
- Known limitations:
-  - Blackwell may log `SM 12.x requires CUDA >= 12.9` from some optional
-    tooling; the tested path uses TRITON attention and cu129 wheels.
-  - Without a working `flash-attn` build, audio quality may be slightly
-    metallic; install FlashAttention when a compatible wheel is available.
-  - First request triggers Triton JIT for rotary / attention kernels (latency
-    spike); subsequent requests are faster.
-  - For longer outputs or batching, you may need to raise `max_model_len` in
-    the deploy YAML and match `max_position_embeddings` in the model config
-    (see the offline example README).
@@ -1,4 +1,4 @@
-# GLM-TTS for Chinese/English TTS
+# GLM-TTS for Chinese/English TTS on 1x GPU

 ## Summary

@@ -103,137 +103,3 @@ python examples/online_serving/text_to_speech/glm_tts/openai_speech_client.py \
 - Key flags: `--omni` is required; `--trust-remote-code` is needed for the GLM-TTS phoneme tokenizer; the DiT stage enables bucketed model-internal CUDA graphs with eager fallback.
 - Voice cloning: requires `ref_audio` + `ref_text` together. Reference audio should be 3-10 seconds. Feature extraction (WhisperVQ tokenizer, CampPlus ONNX, mel) runs on the model side.
 - Known limitations: First request may be slow due to lazy model loading (WhisperVQ, CampPlus ONNX). Warm-cache RTF is approximately 0.6-0.7x on A40.
-
-### 2x non-standard RTX 4090 48GB
-
-This configuration was personally validated on two non-standard RTX 4090 cards
-reporting 49,140 MiB each in `nvidia-smi`. Stock 24GB RTX 4090 cards were not
-validated.
-
-#### Environment
-
- OS: Ubuntu 22.04.1 LTS
- NVIDIA driver: 580.76.05
- Python: 3.12.13
- PyTorch: 2.11.0+cu130
- CUDA runtime and JIT toolkit: 13.0
- vLLM: 0.26.0
- vLLM-Omni: commit `66a9b0c8`, version
-  `0.26.0rc2.dev5+g66a9b0c84`
- FlashInfer: 0.6.14
-
-The host's default `nvcc` was 11.8. The working CUDA toolkit came from the
-Python environment, so `CUDA_HOME` was set to
-`$VIRTUAL_ENV/lib/python3.12/site-packages/nvidia/cu13`.
-
-#### Command
-
-From the repository root, start the async-chunk server with:
-
-```bash
-export CUDA_HOME="$VIRTUAL_ENV/lib/python3.12/site-packages/nvidia/cu13"
-export PATH="$CUDA_HOME/bin:$PATH"
-export LD_LIBRARY_PATH="$CUDA_HOME/lib:${LD_LIBRARY_PATH:-}"
-
-CUDA_VISIBLE_DEVICES=0,1 vllm-omni serve zai-org/GLM-TTS \
-  --omni \
-  --trust-remote-code \
-  --port 8091 \
-  --deploy-config vllm_omni/deploy/glm_tts.yaml \
-  --stage-overrides '{"1":{"devices":"1"}}' \
-  --allowed-local-media-path "${PWD}/tests/assets"
-```
-
-Stage 0 runs on GPU 0, while the override places stage 1 on GPU 1. For the sync
-variant, add `--no-async-chunk` to the same command.
-
-#### Verification
-
-Run the Chinese voice-cloning check:
-
-```bash
-python examples/online_serving/text_to_speech/glm_tts/openai_speech_client.py \
-  --model zai-org/GLM-TTS \
-  --text "今天天气很好，我们一起学习语音模型推理。" \
-  --ref-audio "file://${PWD}/tests/assets/glm_tts/jiayan_zh.wav" \
-  --ref-text "他当时还跟线下其他的站姐吵架，然后，打架进局子了。" \
-  --response-format wav \
-  --output glm_tts_zh.wav
-```
-
-Run the English voice-cloning check with the same Chinese reference:
-
-```bash
-python examples/online_serving/text_to_speech/glm_tts/openai_speech_client.py \
-  --model zai-org/GLM-TTS \
-  --text "Hello, this is a voice cloning test with GLM-TTS." \
-  --ref-audio "file://${PWD}/tests/assets/glm_tts/jiayan_zh.wav" \
-  --ref-text "他当时还跟线下其他的站姐吵架，然后，打架进局子了。" \
-  --response-format wav \
-  --output glm_tts_en.wav
-```
-
-Inspect either output:
-
-```bash
-ffprobe -v error -select_streams a:0 \
-  -show_entries stream=codec_name,sample_rate,channels \
-  -of default=noprint_wrappers=1 glm_tts_zh.wav
-```
-
-Expected output:
-
-```text
-codec_name=pcm_s16le
-sample_rate=24000
-channels=1
-```
-
-The English smoke test produced a valid WAV with an actual duration of 5.020
-seconds.
-
-#### Observed warm-cache results
-
-These observations are from one controlled run, not a hardware or performance
-guarantee. Cold-start and JIT costs were excluded. Values are mean +/- standard
-deviation.
-
-##### Measurement procedure
-
- For the single-GPU server, use the documented command with
-  `CUDA_VISIBLE_DEVICES=0` and omit `--stage-overrides`; both bundled stages
-  remain on GPU 0. For the dual-GPU server, use the command as shown.
- Async chunking is the default. Add `--no-async-chunk` for sync mode.
- For non-streaming measurements, use the exact Chinese client command above.
-  For streaming, add `--stream` to that command and change the output filename
-  to `glm_tts_zh.pcm`; streaming output is raw PCM, not WAV.
- The fixed Chinese prompt and reference were exactly those shown in
-  Verification and yielded 3.900 seconds of audio. Each case used one warm-up
-  followed by three measured requests at concurrency 1.
- Wall time starts immediately before the HTTP POST and stops after the complete
-  response body. TTFA runs from immediately before the POST to the first
-  non-empty audio bytes. RTF is wall time divided by audio duration.
- Peak total device memory used was sampled every 0.2 seconds and reported by
-  NVML via `nvmlDeviceGetMemoryInfo.used`. The readings include background and
-  baseline use and are not baseline-subtracted.
-
-| GPUs | Mode | Response | Wall time (s) | TTFA (s) | RTF |
-|---:|---|---|---:|---:|---:|
-| 1 | Async | Non-streaming | 2.144 +/- 0.076 | -- | 0.550 +/- 0.019 |
-| 2 | Async | Non-streaming | 1.969 +/- 0.130 | -- | 0.505 +/- 0.033 |
-| 1 | Async | Streaming | 2.135 +/- 0.093 | 1.245 +/- 0.178 | 0.548 +/- 0.024 |
-| 2 | Async | Streaming | 1.891 +/- 0.006 | 1.170 +/- 0.042 | 0.485 +/- 0.002 |
-| 1 | Sync | Non-streaming | 1.822 +/- 0.016 | -- | 0.467 +/- 0.004 |
-| 2 | Sync | Non-streaming | 1.792 +/- 0.023 | -- | 0.459 +/- 0.006 |
-
-Moving stage 1 to GPU 1 reduced async non-streaming wall time by 8.2%. It
-reduced async streaming wall time by 11.4% and TTFA by 6.0%, and reduced sync
-wall time by 1.6%. Single- and dual-GPU outputs were bitwise identical only
-within matching execution and response modes.
-
-| Configuration | GPU 0 | GPU 1 |
-|---|---:|---:|
-| Single-GPU async | 31.52 GiB | -- |
-| Dual-GPU async | 29.23 GiB | 2.91 GiB |
-| Single-GPU sync | 31.47 GiB | -- |
-| Dual-GPU sync | 29.23 GiB | 2.91 GiB |
@@ -1,12 +1,10 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project

 """
 Unit tests for metrics.py
 """

-import math
-
 import pytest
 from vllm.benchmarks.serve import TaskType

@@ -68,22 +66,6 @@ def _make_output(prompt_len: int, output_tokens: int = 10) -> MixRequestFuncOutp
    return output


-def _calculate_test_metrics(outputs, goodput=None):
-    return calculate_metrics(
-        input_requests=[],
-        outputs=outputs,
-        dur_s=1.0,
-        tokenizer=None,
-        selected_percentiles=[50.0],
-        goodput_config_dict=goodput or {},
-        task_type=TaskType.GENERATION,
-        selected_percentile_metrics=[],
-        max_concurrency=None,
-        request_rate=float("inf"),
-        benchmark_duration=1.0,
-    )[0]
-
-
 # ============================================================================
 # total_input Tests
 # ============================================================================
@@ -144,166 +126,6 @@ def test_audio_continuity_aggregation():
    assert p99 is not None and p99 > 0.4


-def test_unmeasured_duplex_latency_does_not_add_zero_samples():
-    measured = _make_output(100, output_tokens=2)
-    measured.ttft = 0.1
-    measured.audio_ttfp = 0.2
-    measured.audio_rtf = 0.5
-    measured.duplex_session_metrics = {
-        "mean_ttft_ms": 100.0,
-        "mean_ttfp_ms": 200.0,
-        "mean_rtf": 0.5,
-    }
-    listen_only = _make_output(100, output_tokens=0)
-    listen_only.ttft = listen_only.audio_ttfp = listen_only.audio_rtf = 0.0
-    listen_only.duplex_session_metrics = {
-        "mean_ttft_ms": None,
-        "mean_ttfp_ms": None,
-        "mean_rtf": None,
-    }
-
-    metrics = _calculate_test_metrics([measured, listen_only], {"ttft": 150.0})
-
-    assert metrics.mean_ttft_ms == 100.0
-    assert metrics.mean_audio_ttfp_ms == 200.0
-    assert metrics.mean_audio_rtf == 0.5
-    assert (metrics.num_ttft_samples, metrics.num_audio_ttfp_samples, metrics.num_audio_rtf_samples) == (1, 1, 1)
-    assert metrics.request_goodput == 1.0
-
-
-def test_all_unmeasured_duplex_latency_is_not_reported_as_zero():
-    listen_only = _make_output(100, output_tokens=0)
-    listen_only.duplex_session_metrics = {
-        "mean_ttft_ms": None,
-        "mean_ttfp_ms": None,
-        "mean_rtf": None,
-    }
-
-    metrics = _calculate_test_metrics(
-        [listen_only],
-        {"ttft": float("inf"), "audio_ttft": float("inf")},
-    )
-
-    assert (metrics.num_ttft_samples, metrics.num_audio_ttfp_samples, metrics.num_audio_rtf_samples) == (0, 0, 0)
-    assert math.isnan(metrics.mean_ttft_ms)
-    assert math.isnan(metrics.mean_audio_ttfp_ms)
-    assert math.isnan(metrics.mean_audio_rtf)
-    assert metrics.request_goodput == 0.0
-
-
-def test_unmeasured_duplex_tpot_does_not_add_zero_or_misalign_goodput():
-    missing_tpot = _make_output(100, output_tokens=5)
-    missing_tpot.itl = []
-    missing_tpot.text_latency = missing_tpot.ttft = 0.1
-    missing_tpot.tpot_measured = False
-    missing_tpot.duplex_session_metrics = {"mean_ttft_ms": 100.0}
-
-    slow_ttft = _make_output(100, output_tokens=5)
-    slow_ttft.ttft = 1.0
-    slow_ttft.text_latency = 1.4
-    slow_ttft.itl = [0.1] * 4
-    slow_ttft.duplex_session_metrics = {"mean_ttft_ms": 1000.0}
-
-    metrics = _calculate_test_metrics(
-        [missing_tpot, slow_ttft],
-        {"ttft": 500.0, "tpot": 200.0},
-    )
-
-    assert metrics.num_tpot_samples == 1
-    assert metrics.mean_tpot_ms == pytest.approx(100.0)
-    assert metrics.request_goodput == 0.0
-
-
-def test_all_unmeasured_duplex_token_timing_is_not_reported_as_zero():
-    output = _make_output(100, output_tokens=5)
-    output.itl = []
-    output.text_latency = output.ttft
-    output.tpot_measured = False
-    output.duplex_session_metrics = {"mean_ttft_ms": 100.0}
-
-    metrics = _calculate_test_metrics([output], {"tpot": float("inf")})
-
-    assert (metrics.num_tpot_samples, metrics.num_itl_samples) == (0, 0)
-    assert math.isnan(metrics.mean_tpot_ms)
-    assert math.isnan(metrics.mean_itl_ms)
-    assert metrics.request_goodput == 0.0
-
-
-def test_duplex_response_timings_do_not_build_a_session_token_timeline():
-    output = _make_output(100, output_tokens=5)
-    output.latency = 101.0
-    output.duplex_request_metrics = [
-        {"response_id": "r1", "stage0_tokens": {"itls_ms": [100.0, 100.0]}},
-        {"response_id": "r2", "stage0_tokens": {"itls_ms": [100.0, 100.0]}},
-    ]
-    output.duplex_session_metrics = {"mean_ttft_ms": 100.0}
-
-    metrics = _calculate_test_metrics([output])
-
-    assert math.isnan(metrics.max_output_tokens_per_s)
-    assert metrics.max_concurrent_requests == 1
-    assert metrics.mean_tpot_ms == pytest.approx(100.0)
-    assert metrics.mean_itl_ms == pytest.approx(100.0)
-
-
-def test_unmeasured_tpot_stays_missing_after_tokenizer_fallback():
-    output = _make_output(100, output_tokens=0)
-    output.generated_text = "timing metadata missing"
-    output.itl = []
-    output.text_latency = output.ttft
-    output.tpot_measured = False
-    output.duplex_session_metrics = {"mean_ttft_ms": 100.0}
-
-    def tokenizer(text, *, add_special_tokens):
-        assert text == output.generated_text
-        assert add_special_tokens is False
-        return type("Tokenized", (), {"input_ids": [1, 2, 3]})()
-
-    metrics, _ = calculate_metrics(
-        input_requests=[],
-        outputs=[output],
-        dur_s=1.0,
-        tokenizer=tokenizer,
-        selected_percentiles=[50.0],
-        goodput_config_dict={"tpot": float("inf")},
-        task_type=TaskType.GENERATION,
-        selected_percentile_metrics=[],
-        max_concurrency=None,
-        request_rate=float("inf"),
-        benchmark_duration=1.0,
-    )
-
-    assert metrics.total_output == 3
-    assert metrics.num_tpot_samples == 0
-    assert math.isnan(metrics.mean_tpot_ms)
-    assert metrics.request_goodput == 0.0
-
-
-def test_measured_zero_itl_is_not_treated_as_missing():
-    output = _make_output(100, output_tokens=3)
-    output.itl = [0.0, 0.0]
-    output.duplex_session_metrics = {"mean_ttft_ms": 100.0}
-
-    metrics = _calculate_test_metrics([output], {"tpot": 1.0})
-
-    assert (metrics.num_tpot_samples, metrics.num_itl_samples) == (1, 2)
-    assert metrics.mean_tpot_ms == 0.0
-    assert metrics.mean_itl_ms == 0.0
-    assert metrics.request_goodput == 1.0
-
-
-def test_duplex_goodput_does_not_pair_measurements_from_different_requests():
-    text_only, audio_only = _make_output(100), _make_output(100)
-    text_only.ttft, text_only.audio_ttfp = 0.1, 0.0
-    text_only.duplex_session_metrics = {"mean_ttft_ms": 100.0, "mean_ttfp_ms": None, "mean_rtf": None}
-    audio_only.ttft, audio_only.audio_ttfp = 0.0, 0.2
-    audio_only.duplex_session_metrics = {"mean_ttft_ms": None, "mean_ttfp_ms": 200.0, "mean_rtf": None}
-
-    metrics = _calculate_test_metrics([text_only, audio_only], {"ttft": 500.0, "audio_ttft": 500.0})
-
-    assert metrics.request_goodput == 0.0
-
-
 # ============================================================================
 # TTFT suppression for pure-audio (TTS) benchmarks
 # ============================================================================
@@ -1,778 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from __future__ import annotations
-
-import argparse
-import asyncio
-import base64
-import io
-import json
-import subprocess
-import tarfile
-import threading
-import time
-import wave
-from concurrent.futures import ThreadPoolExecutor
-from pathlib import Path
-
-import pytest
-from vllm.benchmarks.lib.endpoint_request_func import RequestFuncInput
-from vllm.benchmarks.serve import TaskType
-
-from vllm_omni.benchmarks import omniinteract as oi
-from vllm_omni.benchmarks import serve as benchmark_serve
-from vllm_omni.benchmarks.data_modules import omniinteract_dataset as data
-from vllm_omni.benchmarks.metrics.metrics import calculate_metrics
-from vllm_omni.benchmarks.patch import patch as benchmark_patch
-from vllm_omni.entrypoints.cli.benchmark.cli_args import preprocess_serve_args
-from vllm_omni.entrypoints.cli.benchmark.serve import OmniBenchmarkServingSubcommand
-from vllm_omni.experimental.fullduplex.client import RealtimeEventCollector
-from vllm_omni.utils.tracking_parser import TrackingArgumentParser
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.benchmark]
-MODEL = "openbmb/MiniCPM-o-4_5"
-
-
-def _case(tmp_path: Path, *, subset: str = "1q1a", name: str = "video.mp4") -> data.OmniInteractCase:
-    video, annotation = tmp_path / name, tmp_path / f"{Path(name).stem}.json"
-    video.parent.mkdir(parents=True, exist_ok=True)
-    video.touch()
-    annotation.write_text("{}")
-    return data.OmniInteractCase(subset, name, video, annotation, "multi_turn")
-
-
-def _collector(*events: tuple[dict[str, object], float]) -> RealtimeEventCollector:
-    collector = RealtimeEventCollector()
-    for event, received_at in events:
-        collector.add(event, received_at_s=received_at)
-    return collector
-
-
-def _created(response_id: str = "r1") -> dict[str, object]:
-    return {"type": "response.created", "response": {"id": response_id}}
-
-
-def _done(response_id: str = "r1", status: str = "completed") -> dict[str, object]:
-    return {"type": "response.done", "response": {"id": response_id, "status": status}}
-
-
-def _audio(
-    response_id: str = "r1",
-    *,
-    samples: int = 2400,
-    rate: int | None = 24_000,
-    value: int = 1,
-) -> dict[str, object]:
-    event: dict[str, object] = {
-        "type": "response.audio.delta",
-        "response_id": response_id,
-        "format": "pcm16",
-        "delta": base64.b64encode(bytes((value, 0)) * samples).decode(),
-    }
-    if rate is not None:
-        event["sample_rate_hz"] = rate
-    return event
-
-
-def _text(response_id: str = "r1", value: str = "hello") -> dict[str, object]:
-    return {"type": "response.audio_transcript.delta", "response_id": response_id, "delta": value}
-
-
-def _listen(*, buffering: bool = False) -> dict[str, object]:
-    return {
-        "type": "response.listen",
-        "response": {"metadata": {"model_listen": True, "buffering": buffering}},
-    }
-
-
-def _session_options(tmp_path: Path) -> data.OmniInteractSessionOptions:
-    return data.OmniInteractSessionOptions(tmp_path / "artifacts", 10.0, 5.0, "reference.wav", True)
-
-
-def _sample(case: data.OmniInteractCase, options: data.OmniInteractSessionOptions):
-    return data.OmniInteractSampleRequest(
-        prompt="",
-        prompt_len=0,
-        expected_output_len=0,
-        multi_modal_data=None,
-        request_id="measured-0",
-        omniinteract_case=case,
-        omniinteract_options=options,
-    )
-
-
-def _write_dataset(root: Path) -> Path:
-    data_root = root / "data"
-    for subset in ("1q1a", "1q1a_math"):
-        subset_root = data_root / subset
-        (subset_root / "videos").mkdir(parents=True)
-        (subset_root / "annotations").mkdir()
-        (subset_root / "videos" / f"{subset}.mp4").touch()
-        (subset_root / "annotations" / f"{subset}.json").write_text("{}")
-        (subset_root / "video_json_map.json").write_text(
-            json.dumps(
-                {
-                    "entries": [
-                        {
-                            "video": f"videos/{subset}.mp4",
-                            "annotation": f"annotations/{subset}.json",
-                            "scene_type": "multi_turn",
-                        }
-                    ]
-                }
-            )
-        )
-    one_to_many = data_root / "1qna"
-    (one_to_many / "videos_bench" / "nested").mkdir(parents=True)
-    (one_to_many / "annotations" / "nested").mkdir(parents=True)
-    (one_to_many / "videos_bench" / "nested" / "guide.mp4").touch()
-    (one_to_many / "annotations" / "nested" / "guide.json").write_text("{}")
-    return data_root
-
-
-def _successful_output(
-    tmp_path: Path,
-    *,
-    audio_time: float = 10.0,
-    status: str = "completed",
-) -> tuple[data.OmniInteractCase, RealtimeEventCollector, oi.OmniInteractCaseResult]:
-    case = _case(tmp_path)
-    collector = _collector(
-        (_created(), 9.9),
-        (_audio(), audio_time),
-        (_text(), audio_time + 0.01),
-        (_done(status=status), audio_time + 0.1),
-    )
-    result = oi.OmniInteractCaseResult(case.subset, str(case.video_path), "")
-    return case, collector, result
-
-
-def _write_success(
-    root: Path,
-    case: data.OmniInteractCase,
-    collector: RealtimeEventCollector,
-    result: oi.OmniInteractCaseResult,
-    **kwargs,
-):
-    require_response = kwargs.pop("require_response", True)
-    return oi.prepare_success_artifacts(
-        root,
-        case,
-        collector,
-        stream_start=10.0,
-        video_duration_s=1.0,
-        require_response=require_response,
-        result=result,
-        **kwargs,
-    )
-
-
-def test_dataset_discovers_official_layouts_and_total_selection(tmp_path: Path):
-    root = _write_dataset(tmp_path)
-    all_cases = data.discover_omniinteract_cases(root, data.OMNIINTERACT_SUBSETS, num_prompts=0, disable_shuffle=True)
-    selected = data.discover_omniinteract_cases(root, data.OMNIINTERACT_SUBSETS, num_prompts=2, disable_shuffle=True)
-    assert [case.subset for case in all_cases] == ["1q1a", "1q1a_math", "1qna"]
-    assert all_cases[-1].video_rel == "videos_bench/nested/guide.mp4"
-    assert [case.subset for case in selected] == ["1q1a", "1q1a_math"]
-
-
-def _archive(path: Path, member: str) -> None:
-    with tarfile.open(path, "w") as archive:
-        content = b"{}"
-        item = tarfile.TarInfo(member)
-        item.size = len(content)
-        archive.addfile(item, io.BytesIO(content))
-
-
-def test_archive_is_safe_and_atomically_shared(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
-    bad = tmp_path / "bad.tar"
-    _archive(bad, "../escape")
-    with pytest.raises(ValueError, match="Unsafe path"):
-        data._extract_archive(bad, tmp_path / "bad-cache")
-
-    good = tmp_path / "good.tar"
-    _archive(good, "data/1q1a/video_json_map.json")
-    target = tmp_path / "cache"
-    barrier, safe_extract = threading.Barrier(2), data._safe_extract
-    monkeypatch.setattr(data, "_safe_extract", lambda *args: (barrier.wait(), safe_extract(*args)))
-    with ThreadPoolExecutor(2) as executor:
-        roots = list(executor.map(lambda _: data._extract_archive(good, target), range(2)))
-    assert roots[0] == roots[1]
-    assert (roots[0] / "1q1a" / "video_json_map.json").is_file()
-    assert not list(target.glob(".tmp-*"))
-
-
-def test_hub_archive_uses_vllm_filesystem(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
-    source = tmp_path / "source.tar"
-    _archive(source, "data/1q1a/video_json_map.json")
-
-    class FS:
-        def get_file(self, remote: str, local: str) -> None:
-            assert remote == "datasets/org/repo/data.tar.gz"
-            Path(local).write_bytes(source.read_bytes())
-
-    monkeypatch.setenv("HF_HOME", str(tmp_path / "hf"))
-    monkeypatch.setattr(data, "hf_fs", lambda: FS())
-    assert (data.resolve_omniinteract_root(None, "org/repo") / "1q1a").is_dir()
-
-
-def test_media_commands_are_bounded(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
-    calls: list[float] = []
-    commands: list[list[str]] = []
-    bounded_run = oi._run_media_command
-
-    def run(command, *, timeout_s, text=False):
-        calls.append(timeout_s)
-        commands.append(command)
-        if command[0] == "ffprobe":
-            return subprocess.CompletedProcess(command, 0, "1.0", "")
-        return subprocess.CompletedProcess(command, 0, b"", b"")
-
-    monkeypatch.setattr(oi, "_run_media_command", run)
-    duration, pcm, frames = oi.prepare_media(tmp_path / "video.mp4", 1.0, timeout_s=3.0, max_duration_s=1.0)
-    assert (duration, len(pcm), frames, calls) == (1.0, 32_000, [None], [3.0, 3.0, 3.0])
-    assert commands[1][commands[1].index("-t") + 1] == "1.0"
-    assert commands[1][commands[1].index("-fs") + 1] == "32000"
-
-    monkeypatch.setattr(subprocess, "run", lambda *a, **k: (_ for _ in ()).throw(subprocess.TimeoutExpired("x", 3)))
-    with pytest.raises(TimeoutError, match="timed out"):
-        bounded_run(["ffmpeg"], timeout_s=3.0)
-
-
-def test_media_duration_is_bounded_before_decode(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
-    calls = 0
-
-    def run(command, *, timeout_s, text=False):
-        nonlocal calls
-        calls += 1
-        return subprocess.CompletedProcess(command, 0, "601.0", "")
-
-    monkeypatch.setattr(oi, "_run_media_command", run)
-    with pytest.raises(ValueError, match="Invalid video duration"):
-        oi.prepare_media(tmp_path / "video.mp4", 1.0, timeout_s=3.0, max_duration_s=600.0)
-    assert calls == 1
-
-
-def test_final_commit_keeps_a_partial_model_unit():
-    """Exact units retain a sample for the server's correlated final flush."""
-
-    events = [{"session": {"capabilities": {"chunk_period_ms": 1000}}}]
-    exact_unit = b"\0\0" * 16_000
-    assert oi._ensure_final_commit_tail(exact_unit, events) == exact_unit[:-2]
-    assert oi._ensure_final_commit_tail(exact_unit + b"\0\0", events) == exact_unit + b"\0\0"
-
-
-@pytest.mark.parametrize(
-    ("events", "match"),
-    [
-        (((_done(), 0.0),), "without response.created"),
-        (((_created(), 0.0), (_created(), 0.1)), "duplicate response.created"),
-        (((_created(), 0.0), (_done(), 0.1), (_done(), 0.2)), "duplicate response.done"),
-        (
-            (
-                (_created(), 0.0),
-                ({"type": "response.done", "response": {"id": "r1", "status_details": {"type": "failed"}}}, 0.1),
-            ),
-            "reports failure",
-        ),
-    ],
-)
-def test_response_ledger_rejects_identity_errors(events, match: str):
-    with pytest.raises(ValueError, match=match):
-        oi.response_ledger(_collector(*events))
-
-
-class _CompletionClient:
-    def __init__(self, collector: RealtimeEventCollector):
-        self.events, self.acks = collector, []
-
-    def raise_if_reader_stopped(self) -> None:
-        return None
-
-    async def send_playback_ack(self, response_id: str, played_ms: int) -> None:
-        self.acks.append((response_id, played_ms))
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize(
-    ("tail", "succeeds"),
-    [
-        (((_created(), 1.1), (_done(), 1.2)), True),
-        (((_listen(), 1.1),), True),
-        (((_listen(buffering=True), 1.1),), False),
-        ((({"type": "session.closed", "reason": "timeout"}, 1.1),), False),
-    ],
-)
-async def test_completion_requires_a_final_model_decision(tail, succeeds: bool):
-    events = _collector(({"type": "input_audio_buffer.committed"}, 1.0), *tail)
-    coroutine = oi.wait_for_session_completion(
-        _CompletionClient(events), oi._Playback(), commit_from=0, timeout_s=0.08, settle_s=0.0
-    )
-    if succeeds:
-        assert await coroutine == 0
-    else:
-        with pytest.raises((TimeoutError, RuntimeError)):
-            await coroutine
-
-
-@pytest.mark.asyncio
-async def test_deferred_commit_ignores_the_prior_response_terminal():
-    events = _collector(
-        (_created("old"), 0.0),
-        ({"type": "input_audio_buffer.committed", "event": {"overlap_deferred": True}}, 1.0),
-        (_done("old"), 1.1),
-        (_listen(), 1.2),
-    )
-    assert (
-        await oi.wait_for_session_completion(
-            _CompletionClient(events), oi._Playback(), commit_from=1, timeout_s=0.1, settle_s=0.0
-        )
-        == 1
-    )
-
-
-@pytest.mark.asyncio
-async def test_playback_acks_only_after_serial_audio_drain():
-    collector = _collector((_audio(samples=2400), 10.0), (_done(), 10.01))
-    client, playback = _CompletionClient(collector), oi._Playback()
-    await playback.acknowledge(client, now=10.05)
-    assert client.acks == []
-    await playback.acknowledge(client, now=10.1)
-    assert client.acks == [("r1", 100)]
-
-
-@pytest.mark.parametrize(
-    ("event", "match"),
-    [
-        (_audio(rate=16_000), "24000 Hz"),
-        ({**_audio(), "format": "opus"}, "pcm16"),
-        ({**_audio(), "delta": "!"}, "base64"),
-    ],
-)
-def test_playback_rejects_non_official_audio(event: dict[str, object], match: str):
-    playback = oi._Playback()
-    with pytest.raises(ValueError, match=match):
-        playback.ingest(_collector((event, 1.0)))
-
-
-def test_artifacts_publish_official_bundle_and_sparse_deferred_state(tmp_path: Path):
-    case, collector, result = _successful_output(tmp_path)
-    summary = _write_success(
-        tmp_path / "out",
-        case,
-        collector,
-        result,
-    )
-    context = result._artifact_context
-    assert result.success and result.eligible_for_official_eval
-    assert summary["scene_type"] == "multi_turn"
-    assert context and context.spans
-    assert all("delta" not in event for event in context.events if event["type"] == "response.audio.delta")
-    oi.publish_deferred_case_artifacts(tmp_path / "out", case, result)
-    directory = oi._output_dir(tmp_path / "out", case)
-    assert all((directory / name).is_file() for name in oi.SUCCESS_ARTIFACTS)
-    with wave.open(str(directory / "output.wav")) as output:
-        assert (output.getframerate(), output.getnframes()) == (24_000, 24_000)
-    transcript = json.loads((directory / "wav_transcript.json").read_text())
-    assert transcript["text"] == "hello" and transcript["chunks"][0]["timestamp"] == [0.0, 0.1]
-    assert "serialized playback queue" in transcript["timestamp_semantics"]
-    assert result._artifact_context is None
-
-
-@pytest.mark.parametrize(
-    ("audio_time", "status", "reason"),
-    [(10.95, "completed", "audio_clipped"), (10.0, "cancelled", "cancelled_response")],
-)
-def test_ineligible_outputs_are_excluded_from_manifest(tmp_path: Path, audio_time: float, status: str, reason: str):
-    case, collector, result = _successful_output(tmp_path, audio_time=audio_time, status=status)
-    _write_success(tmp_path / "out", case, collector, result, require_response=False)
-    assert reason in result.official_eval_ineligible_reasons
-    oi.write_batch_artifacts(tmp_path / "out", [case], [result])
-    assert (tmp_path / "out" / "official_eval_manifest.jsonl").read_text() == ""
-
-
-def test_artifacts_require_complete_audio_and_transcript_response(tmp_path: Path):
-    case, _, result = _successful_output(tmp_path)
-    collector = _collector((_created(), 10.0), (_audio(), 10.0), (_done(), 10.1))
-    with pytest.raises(ValueError, match="audio and transcript"):
-        _write_success(tmp_path, case, collector, result)
-
-
-def test_publication_failure_removes_partial_success_bundle(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
-    case, collector, result = _successful_output(tmp_path)
-    _write_success(tmp_path, case, collector, result)
-    original = oi._atomic_write_json
-
-    def fail(path: Path, value: object) -> None:
-        if path.name == "events.json":
-            raise OSError("disk full")
-        original(path, value)
-
-    monkeypatch.setattr(oi, "_atomic_write_json", fail)
-    with pytest.raises(OSError, match="disk full"):
-        oi.publish_deferred_case_artifacts(tmp_path, case, result)
-    directory = oi._output_dir(tmp_path, case)
-    assert not any((directory / name).exists() for name in oi.SUCCESS_ARTIFACTS)
-    assert not result.success and "artifact_write_failed" in result.official_eval_ineligible_reasons
-
-
-def test_atomic_write_preserves_destination_on_failure(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
-    destination = tmp_path / "output.wav"
-    destination.write_bytes(b"old")
-    monkeypatch.setattr(oi, "write_pcm16_wav", lambda *a, **k: (_ for _ in ()).throw(OSError("write")))
-    with pytest.raises(OSError):
-        oi._atomic_write_wav(destination, b"\0\0", 24_000)
-    assert destination.read_bytes() == b"old"
-    assert not list(tmp_path.glob(".*.tmp"))
-
-
-class _RealtimeClient:
-    instances: list[_RealtimeClient] = []
-
-    def __init__(self, url: str, **kwargs):
-        self.url, self.events, self.acks, self.configure_kwargs = url, RealtimeEventCollector(), [], {}
-        self.instances.append(self)
-
-    async def __aenter__(self):
-        return self
-
-    async def __aexit__(self, *args):
-        return None
-
-    async def configure(self, model: str, **kwargs) -> None:
-        self.configure_kwargs = kwargs
-        self.events.add({"type": "session.created", "session": {"capabilities": {"chunk_period_ms": 1000}}})
-
-    async def send(self, event: dict[str, object]) -> None:
-        return None
-
-    async def commit(self) -> None:
-        now = time.monotonic()
-        for event, offset in (
-            ({"type": "input_audio_buffer.committed"}, 0.0),
-            (_created(), 0.001),
-            (_audio(samples=24), 0.002),
-            (_text(value="answer"), 0.003),
-            (_done(), 0.004),
-        ):
-            self.events.add(event, received_at_s=now + offset)
-
-    async def send_playback_ack(self, response_id: str, played_ms: int) -> None:
-        self.acks.append((response_id, played_ms))
-
-    async def close_session(self, **kwargs) -> None:
-        self.events.add({"type": "session.closed"})
-
-    def raise_if_reader_stopped(self) -> None:
-        return None
-
-
-@pytest.mark.asyncio
-async def test_public_runner_executes_one_prepared_session(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
-    case = _case(tmp_path)
-    config = oi.OmniInteractBenchmarkConfig(
-        model=MODEL,
-        output_root=tmp_path / "out",
-        ref_audio="ref.wav",
-        require_response=True,
-        extra_body={"custom": "value"},
-    )
-    prepared = data.OmniInteractPreparedInput(1.0, b"\0\0\0\0", ("frame",), "data:audio/wav;base64,ref")
-    monkeypatch.setattr(oi, "RealtimeDuplexClient", _RealtimeClient)
-    monkeypatch.setattr(oi, "_COMPLETION_SETTLE_S", 0.0)
-    result = await oi.run_omniinteract_case(
-        case,
-        config,
-        request_index=0,
-        prepared_input=prepared,
-    )
-    assert result.success and result.transcript == "answer" and result._artifact_context is not None
-    assert not config.output_root.exists()
-    assert "autostart=0" in _RealtimeClient.instances[-1].url
-    assert _RealtimeClient.instances[-1].configure_kwargs["extra_body"] == {"custom": "value"}
-    assert _RealtimeClient.instances[-1].acks == [("r1", 1)]
-
-
-def test_standard_sample_loading_prepares_media_before_timing(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
-    _write_dataset(tmp_path)
-    ref = tmp_path / "ref.wav"
-    ref.touch()
-    parser = TrackingArgumentParser()
-    OmniBenchmarkServingSubcommand.add_cli_args(parser)
-    args = parser.parse_args(
-        [
-            "--backend",
-            "openai-realtime-duplex",
-            "--dataset-name",
-            "omniinteract",
-            "--dataset-path",
-            str(tmp_path),
-            "--model",
-            MODEL,
-            "--endpoint",
-            "/v1/realtime",
-            "--num-prompts",
-            "0",
-            "--omniinteract-ref-audio",
-            str(ref),
-        ]
-    )
-    preprocess_serve_args(args)
-    assert args.endpoint == "/v1/realtime"
-    monkeypatch.setattr(benchmark_patch, "reference_audio_data_url", lambda _: "data:audio/wav;base64,ref")
-    monkeypatch.setattr(benchmark_patch, "prepare_media", lambda *a, **k: (1.0, b"pcm", ["frame"]))
-    samples = benchmark_patch.get_samples(args, None)
-    assert len(samples) == args.num_prompts == 3
-    assert all(sample.omniinteract_prepared_input.video_frames == ("frame",) for sample in samples)
-
-
-def _request(case: data.OmniInteractCase, options: data.OmniInteractSessionOptions) -> RequestFuncInput:
-    request = RequestFuncInput(
-        model=MODEL,
-        model_name=MODEL,
-        prompt="",
-        api_url="http://server:8000/v1/realtime",
-        prompt_len=0,
-        output_len=0,
-        logprobs=None,
-        multi_modal_content=None,
-        ignore_eos=False,
-        request_id="measured-0",
-    )
-    request.omniinteract_case, request.omniinteract_options = case, options
-    return request
-
-
-@pytest.mark.asyncio
-async def test_adapter_requires_and_forwards_exact_prepared_payload(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
-    case, options = _case(tmp_path), _session_options(tmp_path)
-    request = _request(case, options)
-    output = await benchmark_patch.async_request_openai_realtime_duplex(request, session=None)
-    assert not output.success and "prepared before benchmark request timing" in output.error
-
-    prepared = data.OmniInteractPreparedInput(1.0, b"pcm", ("frame",), "data:audio/wav;base64,ref")
-    request.omniinteract_prepared_input = prepared
-    request.extra_headers = {"X-Proxy": "test"}
-    request.extra_body = {"custom": "value"}
-    monkeypatch.setenv("OPENAI_API_KEY", "secret")
-    seen = {}
-
-    async def run(_case_arg, config, **kwargs):
-        seen["headers"] = config.extra_headers
-        seen["extra_body"] = config.extra_body
-        seen.update(kwargs)
-        return oi.OmniInteractCaseResult(
-            case.subset,
-            str(case.video_path),
-            str(options.output_root),
-            success=True,
-            transcript="timing metadata missing",
-            output_tokens=0,
-            duplex_request_metrics=[{"request_metrics": {"ttft_ms": 1.0}}],
-            duplex_session_metrics={"mean_ttft_ms": 10.0},
-        )
-
-    monkeypatch.setattr(benchmark_patch, "run_omniinteract_case", run)
-    output = await benchmark_patch.async_request_openai_realtime_duplex(request, session=None)
-    assert output.success and seen["prepared_input"] is prepared
-    assert seen["headers"] == {"Authorization": "Bearer secret", "X-Proxy": "test", "x-request-id": "measured-0"}
-    assert seen["extra_body"] == {"custom": "value"}
-    assert output.itl == []
-    assert output.tpot_measured is False
-    assert seen["capture_artifacts"] is True
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize(
-    ("request_metrics", "expected_itl", "expected_text_latency"),
-    [
-        (
-            [
-                {"stage0_tokens": {"output_token_count": 3, "itls_ms": [10.0, 20.0]}},
-                {"stage0_tokens": {"output_token_count": 2, "itls_ms": [30.0]}},
-            ],
-            [0.01, 0.02, 0.03],
-            0.16,
-        ),
-        (
-            [
-                {"stage0_tokens": {"output_token_count": 3, "tpot_ms": 10.0}},
-                {"stage0_tokens": {"output_token_count": 2, "tpot_ms": 40.0}},
-            ],
-            [],
-            0.18,
-        ),
-        (
-            [
-                {"stage0_tokens": {"output_token_count": 3, "tpot_ms": 0.0}},
-                {"stage0_tokens": {"output_token_count": 2, "tpot_ms": 0.0}},
-            ],
-            [],
-            0.1,
-        ),
-    ],
-)
-async def test_adapter_reports_exact_or_weighted_token_timing(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-    request_metrics: list[dict[str, object]],
-    expected_itl: list[float],
-    expected_text_latency: float,
-):
-    case, options = _case(tmp_path), _session_options(tmp_path)
-    request = _request(case, options)
-    request.omniinteract_prepared_input = data.OmniInteractPreparedInput(
-        1.0, b"pcm", ("frame",), "data:audio/wav;base64,ref"
-    )
-
-    async def run(*args, **kwargs):
-        return oi.OmniInteractCaseResult(
-            case.subset,
-            str(case.video_path),
-            str(options.output_root),
-            success=True,
-            output_tokens=5,
-            duplex_request_metrics=request_metrics,
-            duplex_session_metrics={"mean_ttft_ms": 100.0},
-        )
-
-    monkeypatch.setattr(benchmark_patch, "run_omniinteract_case", run)
-    output = await benchmark_patch.async_request_openai_realtime_duplex(request, session=None)
-
-    assert output.success
-    assert output.itl == expected_itl
-    assert output.text_latency == pytest.approx(expected_text_latency)
-    assert output.tpot_measured is True
-
-
-def test_batch_finalization_publishes_only_measured_results(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
-    case, options = _case(tmp_path), _session_options(tmp_path)
-    options.output_root.mkdir()
-    sample = _sample(case, options)
-    result = oi.OmniInteractCaseResult(
-        case.subset, str(case.video_path), str(options.output_root), success=True, eligible_for_official_eval=True
-    )
-    output = benchmark_patch.MixRequestFuncOutput(success=True)
-    output.omniinteract_case_result = result
-    published = []
-    monkeypatch.setattr(benchmark_patch, "publish_deferred_case_artifacts", lambda *args: published.append(args))
-    summary = benchmark_patch._finalize_omniinteract_batch([sample], [output])
-    assert summary and summary["total"] == summary["success"] == summary["eligible_for_official_eval"] == 1
-    assert summary["failed"] == summary["successful_but_ineligible"] == summary["audio_clipped_bytes"] == 0
-    assert published == [(options.output_root, case, result)]
-
-
-def test_case_artifact_failures_do_not_discard_serving_metrics(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
-    case, options = _case(tmp_path), _session_options(tmp_path)
-    sample = _sample(case, options)
-    result = oi.OmniInteractCaseResult(
-        case.subset, str(case.video_path), str(options.output_root), success=True, eligible_for_official_eval=True
-    )
-    output = benchmark_patch.MixRequestFuncOutput(success=True, error="inference warning")
-    output.omniinteract_case_result = result
-    monkeypatch.setattr(
-        benchmark_patch,
-        "publish_deferred_case_artifacts",
-        lambda *args: (_ for _ in ()).throw(OSError("case disk full")),
-    )
-    monkeypatch.setattr(
-        benchmark_patch,
-        "write_failure_artifacts",
-        lambda *args: (_ for _ in ()).throw(OSError("failure disk full")),
-    )
-    monkeypatch.setattr(benchmark_patch, "write_omniinteract_batch_artifacts", lambda *args: None)
-
-    summary = benchmark_patch._finalize_omniinteract_batch([sample], [output])
-    metrics, _ = calculate_metrics(
-        [],
-        [output],
-        1.0,
-        None,
-        [50.0],
-        {},
-        TaskType.GENERATION,
-        [],
-        None,
-        float("inf"),
-        1.0,
-    )
-
-    assert summary and summary["failed"] == 1
-    assert summary["artifacts_complete"] is False
-    assert len(summary["artifact_errors"]) == 2
-    assert output.success and metrics.completed == 1
-    assert output.error.startswith("inference warning\n")
-    assert "Artifact publication failed: case disk full" in output.error
-
-
-def test_batch_artifact_failure_removes_partial_batch_files(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
-    case, options = _case(tmp_path), _session_options(tmp_path)
-    sample = _sample(case, options)
-    result = oi.OmniInteractCaseResult(
-        case.subset, str(case.video_path), str(options.output_root), success=True, eligible_for_official_eval=True
-    )
-    output = benchmark_patch.MixRequestFuncOutput(success=True)
-    output.omniinteract_case_result = result
-    monkeypatch.setattr(benchmark_patch, "publish_deferred_case_artifacts", lambda *args: None)
-
-    def fail_batch(root, *args):
-        root.mkdir(parents=True, exist_ok=True)
-        (root / "batch_summary.json").write_text("partial")
-        raise OSError("batch disk full")
-
-    monkeypatch.setattr(benchmark_patch, "write_omniinteract_batch_artifacts", fail_batch)
-
-    summary = benchmark_patch._finalize_omniinteract_batch([sample], [output])
-
-    assert summary and summary["success"] == 1 and summary["artifacts_complete"] is False
-    assert summary["artifact_errors"] == ["Batch artifact publication failed: batch disk full"]
-    assert output.success
-    assert not (options.output_root / "batch_summary.json").exists()
-
-
-@pytest.mark.parametrize(
-    ("field", "value", "match"),
-    [
-        ("omniinteract_ref_audio", None, "ref-audio"),
-        ("endpoint", "/v1/completions", "v1/realtime"),
-        ("max_concurrency", 0, "positive"),
-        ("skip_tokenizer_init", True, "skip-tokenizer-init"),
-    ],
-)
-def test_cli_rejects_incompatible_omniinteract_options(field: str, value, match: str):
-    args = argparse.Namespace(
-        dataset_name="omniinteract",
-        backend="openai-realtime-duplex",
-        endpoint="/v1/realtime",
-        omniinteract_ref_audio="ref.wav",
-        max_concurrency=1,
-        skip_tokenizer_init=False,
-    )
-    setattr(args, field, value)
-    with pytest.raises(ValueError, match=match):
-        preprocess_serve_args(args)
-
-
-def test_whole_benchmark_lock_serializes_a_shared_output_root(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
-    entered, release = threading.Event(), threading.Event()
-    calls: list[int] = []
-
-    async def fake_main_async(args):
-        calls.append(len(calls))
-        if len(calls) == 1:
-            entered.set()
-            await asyncio.to_thread(release.wait)
-        return {"total": 1}
-
-    monkeypatch.setattr(benchmark_serve, "main_async", fake_main_async)
-    args = argparse.Namespace(dataset_name="omniinteract", omniinteract_output_dir=tmp_path, extra_body=None)
-    with ThreadPoolExecutor(2) as executor:
-        first = executor.submit(benchmark_serve.main, args)
-        assert entered.wait(1)
-        second = executor.submit(benchmark_serve.main, args)
-        time.sleep(0.05)
-        assert calls == [0]
-        release.set()
-        assert first.result() == second.result() == {"total": 1}
-    assert calls == [0, 1]
@@ -1,6 +1,3 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
 import argparse
 import json
 import os
@@ -25,7 +22,6 @@ pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.benchmark]
    "dataset_name",
    [
        "daily-omni",
-        "omniinteract",
        "seed-tts",
        "seed-tts-text",
        "seed-tts-design",
@@ -59,7 +55,6 @@ def test_extend_omni_choices_updates_tracking_parser_shadow(dataset_name: str) -
    [
        (["--print-stage"], "print_stage", True),
        (["--daily-omni-input-mode", "audio"], "daily_omni_input_mode", "audio"),
-        (["--omniinteract-subsets", "1qna"], "omniinteract_subsets", ["1qna"]),
        (["--seed-tts-locale", "zh"], "seed_tts_locale", "zh"),
    ],
 )
@@ -85,14 +80,12 @@ def test_add_omni_args_preserves_implicit_defaults() -> None:
    args = parser.parse_args([])
    assert args.print_stage is False
    assert args.daily_omni_input_mode == "all"
-    assert args.omniinteract_subsets == ["1q1a", "1q1a_math", "1qna"]
    assert args.seed_tts_locale == "en"
    assert args.explicit_keys == set()


 def test_update_omni_help_updates_upstream_actions() -> None:
    parser = TrackingArgumentParser()
-    parser.add_argument("--num-prompts", default=1000, help="Number of prompts.")
    parser.add_argument("--percentile-metrics", help="Upstream percentile help.")
    parser.add_argument("--random-mm-limit-mm-per-prompt", help="Upstream limit help.")
    parser.add_argument("--random-mm-bucket-config", help="Upstream bucket help.")
@@ -100,7 +93,6 @@ def test_update_omni_help_updates_upstream_actions() -> None:
    update_omni_help(parser)

    actions = {action.dest: action for action in parser._actions}
-    assert "OmniInteract uses 3" in actions["num_prompts"].help
    assert all(metric in actions["percentile_metrics"].help for metric in ("ttfc", "tpop", "audio_rtf"))
    assert "probabilities are renormalized" in actions["random_mm_limit_mm_per_prompt"].help
    assert "Currently allows for 3 modalities" in actions["random_mm_bucket_config"].help
@@ -128,31 +120,6 @@ def test_preprocess_serve_args_merges_bot_task_without_overriding_extra_body(
    assert args.extra_body == expected


-@pytest.mark.parametrize(
-    ("argv", "expected"),
-    [
-        ([], 3),
-        (["--num-prompts", "0"], 0),
-        (["--num-prompts", "12"], 12),
-    ],
-)
-def test_preprocess_serve_args_applies_safe_omniinteract_prompt_default(
-    argv: list[str],
-    expected: int,
-) -> None:
-    parser = TrackingArgumentParser()
-    parser.add_argument("--dataset-name", default="omniinteract")
-    parser.add_argument("--backend", default="openai-realtime-duplex")
-    parser.add_argument("--endpoint", default="/v1/realtime")
-    parser.add_argument("--omniinteract-ref-audio", default="reference.wav")
-    parser.add_argument("--num-prompts", type=int, default=1000)
-    args = parser.parse_args(argv)
-
-    preprocess_serve_args(args)
-
-    assert args.num_prompts == expected
-
-
@pytest.mark.parametrize(
    ("argv", "expected_extra_body", "expected_explicit"),
    [
@@ -1109,35 +1109,8 @@ class TestDeployConfigLoading:
        with pytest.raises(ValueError, match=r"stage_args.*PipelineConfig.*stages"):
            load_deploy_config(deploy_path)

-    @pytest.mark.parametrize(
-        ("filename", "max_sessions"),
-        [
-            ("minicpmo_4_5.yaml", 4),
-            ("minicpmo_4_5_2gpu.yaml", 4),
-            ("minicpmo_4_5_3gpu.yaml", 4),
-            ("minicpmo_4_5_8x4090.yaml", 1),
-            ("minicpmo_4_5_3gpu_stage1_replicas.yaml", 4),
-            ("minicpmo_4_5_4gpu_stage1_replicas.yaml", 4),
-            ("minicpmo_4_5_8x4090_stage1_replicas.yaml", 1),
-        ],
-    )
-    def test_minicpmo_deploy_configs_enable_duplex(self, filename: str, max_sessions: int):
-        """Every MiniCPM-o profile serves /v1/realtime, so the retired
-        minicpmo_4_5_duplex.yaml overlay has no replacement to fall back on.
-        """
-        deploy = load_deploy_config(Path(get_deploy_config_path(filename)))
-        pipeline = resolve_pipeline_config("minicpmo_4_5")
-        assert isinstance(pipeline, PipelineConfig)
-        stages = merge_pipeline_deploy(pipeline, deploy)
-
-        assert deploy.session_mode == "duplex"
-        assert deploy.active_stream_window == 1
-        assert deploy.duplex_session.max_sessions == max_sessions
-        assert [stage.session_mode for stage in stages] == ["duplex", "duplex", "duplex"]
-        assert [stage.to_omegaconf().session_mode for stage in stages] == ["duplex", "duplex", "duplex"]
-
-    def test_load_minicpmo_default_deploy_config(self):
-        deploy_path = Path(get_deploy_config_path("minicpmo_4_5.yaml"))
+    def test_load_minicpmo_duplex_deploy_config(self):
+        deploy_path = Path(get_deploy_config_path("minicpmo_4_5_duplex.yaml"))

        deploy = load_deploy_config(deploy_path)
        pipeline = resolve_pipeline_config("minicpmo_4_5")
@@ -1145,15 +1118,17 @@ class TestDeployConfigLoading:

        stages = merge_pipeline_deploy(pipeline, deploy)

+        assert deploy.session_mode == "duplex"
        assert deploy.async_chunk is True
-        assert stages[0].yaml_engine_args["async_scheduling"] is True
-        assert stages[1].yaml_engine_args["async_scheduling"] is True
-        assert "Async" in (stages[0].scheduler_cls or "")
-        assert "Async" in (stages[1].scheduler_cls or "")
+        assert deploy.active_stream_window == 1
+        assert [stage.session_mode for stage in stages] == ["duplex", "duplex", "duplex"]
+        assert [stage.to_omegaconf().session_mode for stage in stages] == ["duplex", "duplex", "duplex"]
+        assert [stage.yaml_engine_args["async_scheduling"] for stage in stages] == [False, False, False]
+        assert all("Async" not in (stage.scheduler_cls or "") for stage in stages)
        assert [stage.devices for stage in deploy.stages] == ["0", "0", "0"]
        assert deploy.stages[1].enforce_eager is False
        assert stages[1].yaml_extras["default_sampling_params"]["max_tokens"] == 4096
-        assert stages[1].yaml_extras["default_sampling_params"]["min_tokens"] == 50
+        assert stages[1].yaml_extras["default_sampling_params"]["min_tokens"] == 0
        assert stages[1].yaml_extras["default_sampling_params"]["temperature"] == 0.8
        assert stages[1].yaml_extras["default_sampling_params"]["stop_token_ids"] == [6561]
        assert "codec_sampling_params" not in stages[1].yaml_engine_args
@@ -2141,8 +2116,7 @@ class TestBaseConfigInheritance:
    def test_minicpmo_overlays_inherit_talker_sampling_params(self):
        """Overlays must keep the base Talker codec Sampler knobs."""
        for filename in (
-            "minicpmo_4_5_2gpu.yaml",
-            "minicpmo_4_5_3gpu.yaml",
+            "minicpmo_4_5_duplex.yaml",
            "minicpmo_4_5_3gpu_stage1_replicas.yaml",
            "minicpmo_4_5_4gpu_stage1_replicas.yaml",
            "minicpmo_4_5_8x4090_stage1_replicas.yaml",
@@ -2154,6 +2128,9 @@ class TestBaseConfigInheritance:
            sampling = deploy.stages[1].default_sampling_params
            assert sampling is not None, f"{filename} stage 1 lost default_sampling_params"
            assert sampling["temperature"] == 0.8, filename
+            # Upstream utils.TTSSamplingParams. min_tokens is not checked here:
+            # the duplex overlay drops it to 0 because the model budgets each
+            # generate_chunk itself.
            assert sampling["top_k"] == 25, filename
            assert sampling["top_p"] == 0.85, filename
            assert sampling["repetition_penalty"] == 1.05, filename
@@ -66,8 +66,6 @@ def test_npu_platform_defers_minimax_h3_encoder_patch() -> None:
    runtime_src = src[runtime_start:]
    assert "apply_minimax_h3_qwen3vl_patch" not in init_src
    assert "apply_minimax_h3_qwen3vl_patch" in runtime_src
-    assert "apply_minimax_h3_qwen3vl_sdpa_patch" not in init_src
-    assert "apply_minimax_h3_qwen3vl_sdpa_patch" in runtime_src
    assert "apply_minimax_h3_qwen3vl_swiglu_patch" in runtime_src


@@ -1,317 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-"""Drift checks for the reviewed environment-variable inventory."""
-
-import ast
-import builtins
-from collections import Counter
-from pathlib import Path
-
-import pytest
-
-from vllm_omni.config.environment_variable_inventory import (
-    ENVIRONMENT_VARIABLE_INVENTORY,
-    EnvironmentVariableCategory,
-    ModelEnvironmentVariableDisposition,
-)
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
-
-_REPO_ROOT = Path(__file__).parents[2]
-_PACKAGE_ROOT = _REPO_ROOT / "vllm_omni"
-_INVENTORY_MODULE = _PACKAGE_ROOT / "config" / "environment_variable_inventory.py"
-_REFERENCE_PAGE = _REPO_ROOT / "docs" / "configuration" / "environment_variables.md"
-
-
-def _module_string_constants(tree: ast.Module) -> dict[str, str]:
-    constants: dict[str, str] = {}
-    for statement in tree.body:
-        targets: list[ast.expr] = []
-        value: ast.expr | None = None
-        if isinstance(statement, ast.Assign):
-            targets = statement.targets
-            value = statement.value
-        elif isinstance(statement, ast.AnnAssign):
-            targets = [statement.target]
-            value = statement.value
-        if isinstance(value, ast.Constant) and isinstance(value.value, str):
-            for target in targets:
-                if isinstance(target, ast.Name):
-                    constants[target.id] = value.value
-    return constants
-
-
-def _os_import_aliases(tree: ast.Module) -> tuple[set[str], set[str], set[str]]:
-    os_names: set[str] = set()
-    getenv_names: set[str] = set()
-    environ_names: set[str] = set()
-    for node in ast.walk(tree):
-        if isinstance(node, ast.Import):
-            for imported in node.names:
-                if imported.name == "os":
-                    os_names.add(imported.asname or "os")
-        elif isinstance(node, ast.ImportFrom) and node.module == "os":
-            for imported in node.names:
-                if imported.name == "getenv":
-                    getenv_names.add(imported.asname or imported.name)
-                elif imported.name == "environ":
-                    environ_names.add(imported.asname or imported.name)
-    return os_names, getenv_names, environ_names
-
-
-def _is_environ(node: ast.expr, os_names: set[str], environ_names: set[str]) -> bool:
-    return (
-        isinstance(node, ast.Attribute)
-        and isinstance(node.value, ast.Name)
-        and node.value.id in os_names
-        and node.attr == "environ"
-    ) or (isinstance(node, ast.Name) and node.id in environ_names)
-
-
-def _environment_key_expressions(
-    node: ast.AST,
-    os_names: set[str],
-    getenv_names: set[str],
-    environ_names: set[str],
-) -> list[ast.expr]:
-    """Return key expressions used by one direct environment access."""
-    if isinstance(node, ast.Call) and node.args:
-        func = node.func
-        if (
-            isinstance(func, ast.Attribute)
-            and isinstance(func.value, ast.Name)
-            and func.value.id in os_names
-            and func.attr == "getenv"
-        ) or (isinstance(func, ast.Name) and func.id in getenv_names):
-            return [node.args[0]]
-        if (
-            isinstance(func, ast.Attribute)
-            and _is_environ(func.value, os_names, environ_names)
-            and func.attr in {"get", "pop", "setdefault"}
-        ):
-            return [node.args[0]]
-    elif isinstance(node, ast.Subscript) and _is_environ(node.value, os_names, environ_names):
-        return [node.slice]
-    elif isinstance(node, ast.Compare):
-        expressions: list[ast.expr] = []
-        left_values = [node.left, *node.comparators[:-1]]
-        for left, operator, right in zip(left_values, node.ops, node.comparators):
-            if isinstance(operator, (ast.In, ast.NotIn)) and _is_environ(right, os_names, environ_names):
-                expressions.append(left)
-        return expressions
-    return []
-
-
-def _resolve_environment_name(expression: ast.expr, constants: dict[str, str]) -> str | None:
-    value: str | None = None
-    if isinstance(expression, ast.Constant) and isinstance(expression.value, str):
-        value = expression.value
-    elif isinstance(expression, ast.Name):
-        value = constants.get(expression.id)
-    return value or None
-
-
-def _environment_wrapper_parameters(
-    tree: ast.Module,
-    os_names: set[str],
-    getenv_names: set[str],
-    environ_names: set[str],
-) -> dict[str, set[tuple[str, int | None]]]:
-    """Find local helpers that forward one parameter as an environment key."""
-    wrappers: dict[str, set[tuple[str, int | None]]] = {}
-    for function in (node for node in tree.body if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))):
-        positional = [*function.args.posonlyargs, *function.args.args]
-        parameter_indexes: dict[str, int | None] = {parameter.arg: index for index, parameter in enumerate(positional)}
-        parameter_indexes.update({parameter.arg: None for parameter in function.args.kwonlyargs})
-        forwarded: set[tuple[str, int | None]] = set()
-        for node in ast.walk(function):
-            for expression in _environment_key_expressions(node, os_names, getenv_names, environ_names):
-                if isinstance(expression, ast.Name) and expression.id in parameter_indexes:
-                    forwarded.add((expression.id, parameter_indexes[expression.id]))
-        if forwarded:
-            wrappers[function.name] = forwarded
-    return wrappers
-
-
-def _environment_accesses(path: Path) -> set[str]:
-    """Return statically resolvable names accessed through ``os``."""
-    tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
-    constants = _module_string_constants(tree)
-    os_names, getenv_names, environ_names = _os_import_aliases(tree)
-    wrappers = _environment_wrapper_parameters(tree, os_names, getenv_names, environ_names)
-    names: set[str] = set()
-
-    for node in ast.walk(tree):
-        for expression in _environment_key_expressions(node, os_names, getenv_names, environ_names):
-            if name := _resolve_environment_name(expression, constants):
-                names.add(name)
-
-        if isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
-            for parameter_name, position in wrappers.get(node.func.id, set()):
-                argument = node.args[position] if position is not None and position < len(node.args) else None
-                if argument is None:
-                    argument = next(
-                        (keyword.value for keyword in node.keywords if keyword.arg == parameter_name),
-                        None,
-                    )
-                if argument is not None and (name := _resolve_environment_name(argument, constants)):
-                    names.add(name)
-
-    return names
-
-
-def test_inventory_matches_reviewed_snapshot_counts():
-    """Make an inventory expansion an explicit review decision."""
-    category_counts = Counter(item.category for item in ENVIRONMENT_VARIABLE_INVENTORY.values())
-    assert category_counts == {
-        EnvironmentVariableCategory.PUBLIC_OMNI: 24,
-        EnvironmentVariableCategory.INHERITED_VLLM: 20,
-        EnvironmentVariableCategory.PLATFORM_EXTERNAL: 27,
-        EnvironmentVariableCategory.MODEL_SPECIFIC: 56,
-        EnvironmentVariableCategory.BENCHMARK_TRANSITIONAL: 20,
-        EnvironmentVariableCategory.INTERNAL: 2,
-    }
-
-    disposition_counts = Counter(
-        item.model_disposition
-        for item in ENVIRONMENT_VARIABLE_INVENTORY.values()
-        if item.category is EnvironmentVariableCategory.MODEL_SPECIFIC
-    )
-    assert {disposition: disposition_counts[disposition] for disposition in ModelEnvironmentVariableDisposition} == {
-        ModelEnvironmentVariableDisposition.PROMOTE: 33,
-        ModelEnvironmentVariableDisposition.REQUEST_SCOPE: 6,
-        ModelEnvironmentVariableDisposition.EXTERNAL: 0,
-        ModelEnvironmentVariableDisposition.INTERNALIZE: 11,
-        ModelEnvironmentVariableDisposition.DEPRECATE_REMOVE: 6,
-    }
-
-
-def test_new_public_omni_names_use_project_prefix():
-    """Grandfather legacy names without allowing more prefix exceptions."""
-    legacy_public_names = {
-        "DIFFUSION_ATTENTION_BACKEND",
-        "DIFFUSION_CACHE_ADAPTER",
-        "DIFFUSION_CACHE_BACKEND",
-        "OMNI_DIFFUSION_PROMPT_EMBED_CACHE",
-        "OMNI_DIFFUSION_PROMPT_EMBED_CACHE_SIZE",
-        "OMNI_DIFFUSION_SESSION_STATE_MANAGER",
-        "OMNI_DIFFUSION_SESSION_STATE_MANAGER_MAX_SESSIONS",
-        "SPEAKER_MAX_UPLOADED",
-        "SPEAKER_SAMPLES_DIR",
-        "VLLM_VIDEO_ASYNC_CHUNK",
-        "VLLM_VIDEO_AUDIO_DELTA_MODE",
-    }
-    public_names = {
-        name
-        for name, item in ENVIRONMENT_VARIABLE_INVENTORY.items()
-        if item.category is EnvironmentVariableCategory.PUBLIC_OMNI
-    }
-
-    assert {name for name in public_names if not name.startswith("VLLM_OMNI_")} == legacy_public_names
-
-
-def test_statically_resolvable_environment_accesses_are_classified():
-    discovered: set[str] = set()
-    for path in _PACKAGE_ROOT.rglob("*.py"):
-        discovered.update(_environment_accesses(path))
-
-    assert discovered - ENVIRONMENT_VARIABLE_INVENTORY.keys() == set()
-
-
-def test_model_and_benchmark_inventory_entries_are_still_referenced():
-    """Reject transitional rows after their implementation has disappeared."""
-    package_source = "\n".join(
-        path.read_text(encoding="utf-8") for path in _PACKAGE_ROOT.rglob("*.py") if path != _INVENTORY_MODULE
-    )
-    transitional_categories = {
-        EnvironmentVariableCategory.MODEL_SPECIFIC,
-        EnvironmentVariableCategory.BENCHMARK_TRANSITIONAL,
-    }
-
-    stale_names = {
-        name
-        for name, item in ENVIRONMENT_VARIABLE_INVENTORY.items()
-        if item.category in transitional_categories and name not in package_source
-    }
-
-    assert stale_names == set()
-
-
-def test_environment_scanner_covers_indirection_aliases_membership_and_casing():
-    expected_by_path = {
-        "metrics/definitions.py": {
-            "VLLM_OMNI_BENCH_AUDIO_CHANNELS",
-            "VLLM_OMNI_BENCH_AUDIO_SAMPLE_RATE",
-        },
-        "entrypoints/openai/video_stream_envs.py": {
-            "VLLM_VIDEO_ASYNC_CHUNK",
-            "VLLM_VIDEO_AUDIO_DELTA_MODE",
-        },
-        "model_executor/models/mimo_audio/mimo_audio.py": {"model_stage"},
-        "model_executor/models/moss_tts/modeling_moss_tts_local_depth.py": {"MOSS_TTS_DEBUG_STOP"},
-        "distributed/ray_utils/utils.py": {"RAY_RAYLET_PID"},
-    }
-    for relative_path, expected in expected_by_path.items():
-        assert expected <= _environment_accesses(_PACKAGE_ROOT / relative_path)
-
-
-def test_generated_server_storage_environment_names_are_classified():
-    from vllm_omni.config.server_settings import FileBackend
-
-    generated_names = {
-        f"VLLM_OMNI_SERVER_STORAGE__{field_name.upper()}"
-        for field_name in FileBackend.model_fields
-        if field_name != "type"
-    }
-    assert generated_names <= ENVIRONMENT_VARIABLE_INVENTORY.keys()
-
-
-def test_public_omni_variables_are_in_the_reference_page():
-    reference = _REFERENCE_PAGE.read_text(encoding="utf-8")
-    missing = {
-        name
-        for name, item in ENVIRONMENT_VARIABLE_INVENTORY.items()
-        if item.is_public_omni and f"`{name}`" not in reference
-    }
-    assert missing == set()
-
-
-def test_secret_values_are_marked_for_redaction():
-    assert {name for name, item in ENVIRONMENT_VARIABLE_INVENTORY.items() if item.redact_value} == {
-        "HF_TOKEN",
-        "HUGGINGFACE_HUB_TOKEN",
-        "OPENAI_API_KEY",
-    }
-
-
-def test_collect_env_reports_only_safe_public_omni_values(monkeypatch):
-    from collect_env import get_env_vars
-
-    monkeypatch.setenv("DIFFUSION_CACHE_BACKEND", "tea_cache")
-    monkeypatch.setenv("HF_TOKEN", "hf-secret")
-    monkeypatch.setenv("OPENAI_API_KEY", "openai-secret")
-    monkeypatch.setenv("VLLM_OMNI_REPLICA_ID", "internal-replica")
-
-    report = get_env_vars()
-
-    assert "DIFFUSION_CACHE_BACKEND=tea_cache" in report.splitlines()
-    assert "hf-secret" not in report
-    assert "openai-secret" not in report
-    assert "VLLM_OMNI_REPLICA_ID" not in report
-
-
-@pytest.mark.parametrize("error_type", [ImportError, OSError, AssertionError, RuntimeError])
-def test_collect_env_survives_inventory_import_error(monkeypatch, error_type):
-    from collect_env import get_env_vars
-
-    real_import = builtins.__import__
-
-    def fail_inventory_import(name, *args, **kwargs):
-        if name == "vllm_omni.config.environment_variable_inventory":
-            raise error_type("broken vllm-omni installation")
-        return real_import(name, *args, **kwargs)
-
-    monkeypatch.setattr(builtins, "__import__", fail_inventory_import)
-    monkeypatch.setenv("CUDA_VISIBLE_DEVICES", "0")
-
-    assert "CUDA_VISIBLE_DEVICES=0" in get_env_vars().splitlines()
@@ -100,7 +100,6 @@ def _make_drain_sched(session: Request) -> MagicMock:
    sched.pending_stop_after_extraction = set()
    sched.connector = None
    sched.kv_cache_manager.take_events.return_value = None
-    sched.kv_cache_manager.estimate_cached_tokens.return_value = 0
    sched.finished_req_ids_dict = {}
    sched.make_stats.return_value = None
    return sched
@@ -93,7 +93,6 @@ def _run_resumable_segment_stop(
    sched.pending_stop_after_extraction = set()
    sched.connector = None
    sched.kv_cache_manager.take_events.return_value = None
-    sched.kv_cache_manager.estimate_cached_tokens.return_value = 0
    sched.finished_req_ids_dict = {}
    sched.make_stats.return_value = None

@@ -199,7 +198,6 @@ def test_resumable_segment_boundary_keeps_pre_transition_send_watermark() -> Non
        inter_stage_output,
        session,
        True,
-        new_token_ids=[42],
        confirmed_num_computed_tokens=26,
    )

@@ -228,7 +226,6 @@ def test_running_decode_step_without_inter_stage_payload_does_not_raise() -> Non
    sched.pending_stop_after_extraction = set()
    sched.connector = None
    sched.kv_cache_manager.take_events.return_value = None
-    sched.kv_cache_manager.estimate_cached_tokens.return_value = 0
    sched.finished_req_ids_dict = {}
    sched.make_stats.return_value = None

@@ -255,37 +252,6 @@ def test_running_decode_step_without_inter_stage_payload_does_not_raise() -> Non
    sched.chunk_transfer_adapter.save_async.assert_not_called()


-def test_queued_streaming_update_on_async_stop_fences_in_flight_once() -> None:
-    """Native duplex + async: the next unit is usually already queued when the
-    current one stops, so _handle_stopped_request applies the update and the
-    stop site below it fences the same in-flight decode a second time. An
-    accumulated residue outlives the drain and swallows the next unit's
-    listen/speak, which the client sees as silence until its timeout.
-    """
-    session = _make_request()
-    session.status = RequestStatus.RUNNING
-    session.resumable = True
-    session.append_output_token_ids([7])
-    session.num_computed_tokens = 4
-    session.num_output_placeholders = 1
-    # This step's frame (settled to 0 by update_from_output) plus one extra
-    # async decode still in flight.
-    session.num_in_flight_tokens = 2
-
-    sched = _make_scheduler(stage_id=0)
-    sched._enqueue_waiting_request = MagicMock()
-
-    def handle_stopped(request: Request) -> bool:
-        sched._update_request_as_session(request, _make_update([10, 20]))
-        return False
-
-    _run_resumable_segment_stop(session, handle_stopped=handle_stopped)
-
-    # Exactly the one unreported decode, so the drain reaches zero before the
-    # new segment's first frame arrives.
-    assert session.num_stale_output_tokens == session.num_in_flight_tokens == 1
-
-
 def test_stage0_streaming_update_discards_outstanding_async_placeholder_token() -> None:
    sched = _make_scheduler(stage_id=0)
    session = _make_request()
@@ -430,33 +396,3 @@ def test_ready_async_chunk_prompt_replacement_releases_stale_kv_once() -> None:
    assert sched.chunk_transfer_adapter.replaced_streaming_prompt_ids == set()
    assert sched.chunk_transfer_adapter.requests_with_ready_chunks == {session.request_id}
    assert sched.chunk_transfer_adapter.requests_num_chunks_sent == {}
-
-
-def test_chunk_segment_cleanup_keeps_requeued_resumable_receiver() -> None:
-    """A WAITING_FOR_CHUNK stop must not delete its newly parked session."""
-    session = _make_request()
-    session.resumable = True
-    session.status = RequestStatus.WAITING_FOR_STREAMING_REQ
-
-    def queue(*requests):
-        result = MagicMock()
-        result.requests = set(requests)
-        result.add_request.side_effect = result.requests.add
-        result.remove_requests.side_effect = result.requests.difference_update
-        return result
-
-    sched = OmniARScheduler.__new__(OmniARScheduler)
-    sched.running = []
-    sched.waiting = queue()
-    sched.skipped_waiting = queue(session)
-    sched.num_waiting_for_streaming_input = 1
-    sched.chunk_transfer_adapter = SimpleNamespace(segment_finished_requests={session.request_id})
-
-    sched._resume_downstream_chunk_receiver(session)
-    sched._remove_stopped_requests_from_queues(set(), {session})
-
-    assert session.status == RequestStatus.WAITING
-    assert session in sched.waiting.requests
-    assert session not in sched.skipped_waiting.requests
-    assert sched.num_waiting_for_streaming_input == 0
-    assert session.request_id not in sched.chunk_transfer_adapter.segment_finished_requests
@@ -138,7 +138,6 @@ def test_resumable_generation_stop_marks_segment_boundary() -> None:
    sched.recompute_kv_load_failures = False
    sched.connector = None
    sched.kv_cache_manager.take_events.return_value = None
-    sched.kv_cache_manager.estimate_cached_tokens.return_value = 0
    sched.finished_req_ids_dict = {}
    sched.make_stats.return_value = None

@@ -1,168 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-"""v0.28 deferred KV-block free fence in the Omni schedulers (#6606 review).
-
-Upstream v0.28 (defer_block_free) advances ``sched_step_seq`` for every
-non-empty scheduled step and, at the top of ``update_from_output()``,
-advances ``processed_step_seq`` and drains the deferred frees. The Omni
-schedulers each carried only half of that contract:
-
- ``OmniARScheduler.schedule()`` delegates to ``super().schedule()`` (fence
-  advances) but its reimplemented ``update_from_output()`` never advanced
-  ``processed_step_seq`` nor drained -> deferred blocks accumulate without
-  bound under async/PP KV-consumer configurations.
- ``OmniGenerationScheduler`` reimplements both: the fast-path
-  ``schedule()`` never advanced ``sched_step_seq`` (so finished requests
-  freed blocks an in-flight GPU step could still be writing) and its
-  ``update_from_output()`` never drained.
-
-These tests pin the restored contract at the call boundary; the drain and
-free logic itself is upstream-tested.
-"""
-
-from __future__ import annotations
-
-from unittest.mock import MagicMock
-
-import pytest
-
-# Imports must run in this order: vllm_omni applies patches to vllm.v1.request
-# before Request / RequestStatus are bound in this module.
-# isort: off
-import vllm_omni  # noqa: F401 - import for side effects (patch vLLM)
-from vllm.sampling_params import SamplingParams
-from vllm.v1.core.sched.interface import PauseState
-from vllm.v1.core.sched.output import SchedulerOutput
-from vllm.v1.core.sched.request_queue import SchedulingPolicy
-from vllm.v1.outputs import ModelRunnerOutput
-from vllm.v1.request import Request, RequestStatus
-from vllm_omni.core.sched.omni_ar_scheduler import OmniARScheduler
-from vllm_omni.core.sched.omni_generation_scheduler import OmniGenerationScheduler
-
-# isort: on
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
-
-
-def _make_update_sched(scheduler_cls) -> MagicMock:
-    """MagicMock scheduler driving the real ``update_from_output`` with an
-    empty batch; only the fence state carries real values."""
-    sched = MagicMock()
-    sched.requests = {}
-    sched.perf_metrics = None
-    sched.chunk_transfer_adapter = None
-    sched.defer_block_free = True
-    sched.processed_step_seq = 0
-    return sched
-
-
-def _empty_frame(*, total_num_scheduled_tokens: int):
-    scheduler_output = MagicMock(spec=SchedulerOutput)
-    scheduler_output.num_scheduled_tokens = {}
-    scheduler_output.total_num_scheduled_tokens = total_num_scheduled_tokens
-    model_runner_output = MagicMock(spec=ModelRunnerOutput)
-    model_runner_output.sampled_token_ids = []
-    model_runner_output.logprobs = None
-    model_runner_output.prompt_logprobs_dict = {}
-    model_runner_output.pooler_output = None
-    model_runner_output.num_nans_in_logits = None
-    model_runner_output.kv_connector_output = None
-    model_runner_output.cudagraph_stats = None
-    return scheduler_output, model_runner_output
-
-
-@pytest.mark.parametrize("scheduler_cls", [OmniARScheduler, OmniGenerationScheduler])
-def test_update_from_output_advances_fence_and_drains(scheduler_cls) -> None:
-    sched = _make_update_sched(scheduler_cls)
-    scheduler_output, model_runner_output = _empty_frame(total_num_scheduled_tokens=3)
-
-    scheduler_cls.update_from_output(sched, scheduler_output, model_runner_output)
-
-    assert sched.processed_step_seq == 1
-    sched._drain_deferred_frees.assert_called_once_with()
-
-
-@pytest.mark.parametrize("scheduler_cls", [OmniARScheduler, OmniGenerationScheduler])
-def test_update_from_output_zero_token_step_leaves_fence(scheduler_cls) -> None:
-    """0-token steps do not advance the fence upstream (their seq was never
-    advanced in schedule()); draining on them would run ahead of the GPU."""
-    sched = _make_update_sched(scheduler_cls)
-    scheduler_output, model_runner_output = _empty_frame(total_num_scheduled_tokens=0)
-
-    scheduler_cls.update_from_output(sched, scheduler_output, model_runner_output)
-
-    assert sched.processed_step_seq == 0
-    sched._drain_deferred_frees.assert_not_called()
-
-
-@pytest.mark.parametrize("scheduler_cls", [OmniARScheduler, OmniGenerationScheduler])
-def test_update_from_output_defer_disabled_leaves_fence(scheduler_cls) -> None:
-    sched = _make_update_sched(scheduler_cls)
-    sched.defer_block_free = False
-    scheduler_output, model_runner_output = _empty_frame(total_num_scheduled_tokens=3)
-
-    scheduler_cls.update_from_output(sched, scheduler_output, model_runner_output)
-
-    assert sched.processed_step_seq == 0
-    sched._drain_deferred_frees.assert_not_called()
-
-
-def _make_fast_path_sched(*, defer_block_free: bool) -> tuple[MagicMock, Request]:
-    """MagicMock scheduler that drives the real generation fast-path
-    ``schedule()`` over one running one-shot request."""
-    request = Request(
-        request_id="req-fence",
-        prompt_token_ids=[1, 2, 3],
-        sampling_params=SamplingParams(max_tokens=4),
-        pooling_params=None,
-        arrival_time=100.0,
-        block_hasher=None,
-    )
-    request.status = RequestStatus.RUNNING
-
-    sched = MagicMock()
-    sched.max_num_scheduled_tokens = 8
-    sched._pause_state = PauseState.UNPAUSED
-    sched.requests = {request.request_id: request}
-    sched.running = [request]
-    sched.waiting = []  # falsy: the waiting loop never runs
-    sched.policy = SchedulingPolicy.FCFS
-    sched.chunk_transfer_adapter = None
-    sched.scheduler_config = MagicMock(enable_chunked_prefill=True)
-    sched.num_lookahead_tokens = 0
-    sched.log_stats = False
-    sched.kv_cache_config = MagicMock(kv_cache_groups=[])
-    sched.use_v2_model_runner = False
-    sched.prev_step_scheduled_req_ids = set()
-    sched.needs_kv_cache_zeroing = False
-    sched.connector = None
-    sched.ec_connector = None
-    sched.defer_block_free = defer_block_free
-    sched.sched_step_seq = 0
-    # last_sched_seq stamping order: _update_after_schedule must observe the
-    # already-advanced fence value, as upstream schedule() guarantees.
-    sched.seq_at_update_after_schedule = None
-
-    def _capture(_scheduler_output):
-        sched.seq_at_update_after_schedule = sched.sched_step_seq
-
-    sched._update_after_schedule.side_effect = _capture
-    return sched, request
-
-
-def test_fast_path_schedule_advances_fence_before_update_after_schedule() -> None:
-    sched, request = _make_fast_path_sched(defer_block_free=True)
-
-    OmniGenerationScheduler.schedule(sched)
-
-    assert sched.sched_step_seq == 1
-    assert sched.seq_at_update_after_schedule == 1
-
-
-def test_fast_path_schedule_defer_disabled_leaves_fence() -> None:
-    sched, request = _make_fast_path_sched(defer_block_free=False)
-
-    OmniGenerationScheduler.schedule(sched)
-
-    assert sched.sched_step_seq == 0
@@ -1,180 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-"""v0.28 EC request-finish contract in the Omni schedulers (#6606 review).
-
-Upstream v0.28 ``_free_request()`` fires ``ec_connector.request_finished()``
-BEFORE the encoder cache is freed (so the connector can inspect per-request
-state), honors its delayed-free result, and returns the generated
-``ec_transfer_params``; ``update_from_output()`` then carries them into the
-``EngineCoreOutput``. ``OmniARScheduler`` previously skipped the hook and
-always returned ``None``; both Omni schedulers discarded the second tuple
-item, so a remote encoder-cache handle could never reach the frontend.
-"""
-
-from __future__ import annotations
-
-from unittest.mock import MagicMock
-
-import pytest
-
-# Imports must run in this order: vllm_omni applies patches to vllm.v1.request
-# before Request / RequestStatus are bound in this module.
-# isort: off
-import vllm_omni  # noqa: F401 - import for side effects (patch vLLM)
-from vllm.sampling_params import SamplingParams
-from vllm.v1.core.sched.output import SchedulerOutput
-from vllm.v1.outputs import ModelRunnerOutput
-from vllm.v1.request import Request, RequestStatus
-from vllm_omni.core.sched.omni_ar_scheduler import OmniARScheduler
-from vllm_omni.core.sched.omni_generation_scheduler import OmniGenerationScheduler
-
-# isort: on
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
-
-EC_PARAMS = {"remote_encoder_cache_handle": "ec-1"}
-
-
-def _make_free_request_sched(*, ec_connector) -> tuple[OmniARScheduler, MagicMock]:
-    """Minimal real-`_free_request` harness; `order` records the EC hook
-    firing relative to the encoder-cache free."""
-    order = MagicMock()
-    sched = OmniARScheduler.__new__(OmniARScheduler)
-    sched._omits_kv_transfer_cache = {}
-    sched._connector_finished = lambda request: (False, None)
-    sched.ec_connector = ec_connector
-    if ec_connector is not None:
-        order.attach_mock(ec_connector.request_finished, "request_finished")
-    sched.encoder_cache_manager = MagicMock()
-    order.attach_mock(sched.encoder_cache_manager.free, "encoder_cache_free")
-    sched.finished_req_ids = set()
-    sched._new_prompt_len_snapshot = {}
-    sched.finished_req_ids_dict = None
-    sched._should_transfer_kv_for_request = lambda req_id: False
-    sched._free_blocks = MagicMock()
-    sched._free_input_coordinator_request = MagicMock()
-    sched.chunk_transfer_adapter = None
-    return sched, order
-
-
-class _FakeFinishedRequest:
-    def __init__(self, request_id: str) -> None:
-        self.request_id = request_id
-
-    def is_finished(self) -> bool:
-        return True
-
-
-def test_free_request_fires_ec_hook_before_encoder_cache_free() -> None:
-    ec_connector = MagicMock()
-    ec_connector.request_finished.return_value = (False, EC_PARAMS)
-    sched, order = _make_free_request_sched(ec_connector=ec_connector)
-    request = _FakeFinishedRequest("req-ec")
-
-    kv_params, ec_params = sched._free_request(request)
-
-    assert ec_params == EC_PARAMS
-    ec_connector.request_finished.assert_called_once_with(request)
-    hook_calls = [name for name, *_ in order.mock_calls]
-    assert hook_calls.index("request_finished") < hook_calls.index("encoder_cache_free")
-    sched._free_blocks.assert_called_once_with(request)
-
-
-def test_free_request_honors_ec_delayed_free() -> None:
-    ec_connector = MagicMock()
-    ec_connector.request_finished.return_value = (True, EC_PARAMS)
-    sched, _ = _make_free_request_sched(ec_connector=ec_connector)
-    request = _FakeFinishedRequest("req-ec-delay")
-
-    kv_params, ec_params = sched._free_request(request)
-
-    assert ec_params == EC_PARAMS
-    sched._free_blocks.assert_not_called()
-
-
-def test_free_request_without_ec_connector_returns_none() -> None:
-    sched, _ = _make_free_request_sched(ec_connector=None)
-    request = _FakeFinishedRequest("req-no-ec")
-
-    kv_params, ec_params = sched._free_request(request)
-
-    assert ec_params is None
-    sched._free_blocks.assert_called_once_with(request)
-
-
-def _make_finishing_request() -> Request:
-    request = Request(
-        request_id="req-ec-finish",
-        prompt_token_ids=[1, 2, 3],
-        sampling_params=SamplingParams(max_tokens=4),
-        pooling_params=None,
-        arrival_time=100.0,
-        block_hasher=None,
-    )
-    request.status = RequestStatus.RUNNING
-    return request
-
-
-def _make_finish_sched(request: Request) -> MagicMock:
-    """MagicMock scheduler driving the real ``update_from_output`` through a
-    finishing request; ``_free_request`` reports EC transfer params."""
-    sched = MagicMock()
-    sched.requests = {request.request_id: request}
-    sched.perf_metrics = None
-    sched.defer_block_free = False
-    sched.structured_output_manager.should_advance.return_value = False
-    sched._process_kv_transfer_trigger.return_value = False
-    sched._maybe_decode_pooling_output.return_value = None
-    sched._handle_stopped_request.return_value = True
-    sched._free_request.return_value = (None, EC_PARAMS)
-    sched.kv_cache_manager.estimate_cached_tokens.return_value = 0
-    sched.chunk_transfer_adapter = None
-    sched.finished_req_ids_dict = None
-    sched._new_prompt_len_snapshot = {}
-    return sched
-
-
-def test_ar_update_from_output_carries_ec_params_to_engine_output() -> None:
-    request = _make_finishing_request()
-    sched = _make_finish_sched(request)
-    sched._update_request_with_output.return_value = ([42], True)
-
-    engine_core_outputs = OmniARScheduler.update_from_output(sched, *_finish_frame_parts(request))
-
-    (eco,) = engine_core_outputs[request.client_index].outputs
-    assert eco.ec_transfer_params == EC_PARAMS
-    sched._free_request.assert_called_once_with(request)
-
-
-def _finish_frame_parts(request: Request):
-    scheduler_output = MagicMock(spec=SchedulerOutput)
-    scheduler_output.num_scheduled_tokens = {request.request_id: 1}
-    scheduler_output.total_num_scheduled_tokens = 1
-    scheduler_output.scheduled_spec_decode_tokens = {}
-    scheduler_output.num_invalid_spec_tokens = 0
-
-    model_runner_output = MagicMock(spec=ModelRunnerOutput)
-    model_runner_output.sampled_token_ids = [[42]]
-    model_runner_output.logprobs = None
-    model_runner_output.prompt_logprobs_dict = {}
-    model_runner_output.pooler_output = None
-    model_runner_output.num_nans_in_logits = None
-    model_runner_output.kv_connector_output = None
-    model_runner_output.cudagraph_stats = None
-    model_runner_output.req_id_to_index = {request.request_id: 0}
-    model_runner_output.routed_experts = None
-    return scheduler_output, model_runner_output
-
-
-def test_generation_update_from_output_carries_ec_params_to_engine_output() -> None:
-    request = _make_finishing_request()
-    # One-shot generation finish: the whole prompt is computed.
-    request.num_computed_tokens = len(request.prompt_token_ids)
-    sched = _make_finish_sched(request)
-
-    engine_core_outputs = OmniGenerationScheduler.update_from_output(sched, *_finish_frame_parts(request))
-
-    (eco,) = engine_core_outputs[request.client_index].outputs
-    assert eco.ec_transfer_params == EC_PARAMS
-    sched._free_request.assert_called_once_with(request)
@@ -1,126 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-"""v0.28 prefill-stats finalization in the Omni schedulers (#6606 review).
-
-Upstream v0.28 finalizes prefill statistics with
-``PrefillStats.finalize(kv_cache_manager.estimate_cached_tokens(request))``
-before emitting them, which computes ``num_cache_creation_tokens`` (tokens
-computed and written to the prefix cache). Both Omni schedulers previously
-emitted ``take_prefill_stats()`` raw, so creation usage was always 0.
-"""
-
-from __future__ import annotations
-
-from unittest.mock import MagicMock
-
-import pytest
-
-# Imports must run in this order: vllm_omni applies patches to vllm.v1.request
-# before Request / RequestStatus are bound in this module.
-# isort: off
-import vllm_omni  # noqa: F401 - import for side effects (patch vLLM)
-from vllm.sampling_params import SamplingParams
-from vllm.v1.core.sched.output import SchedulerOutput
-from vllm.v1.outputs import ModelRunnerOutput
-from vllm.v1.request import Request, RequestStatus
-from vllm_omni.core.sched.omni_ar_scheduler import OmniARScheduler
-from vllm_omni.core.sched.omni_generation_scheduler import OmniGenerationScheduler
-
-# isort: on
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
-
-
-def _make_request() -> Request:
-    request = Request(
-        request_id="req-prefill-stats",
-        prompt_token_ids=[1, 2, 3],
-        sampling_params=SamplingParams(max_tokens=4),
-        pooling_params=None,
-        arrival_time=100.0,
-        block_hasher=None,
-    )
-    request.status = RequestStatus.RUNNING
-    # A scheduled prefill: 3 prompt tokens, 1 from the local prefix cache.
-    request.prefill_stats.set(
-        num_prompt_tokens=3,
-        num_local_cached_tokens=1,
-        num_external_cached_tokens=0,
-    )
-    return request
-
-
-def _make_sched(request: Request) -> MagicMock:
-    sched = MagicMock()
-    sched.requests = {request.request_id: request}
-    sched.perf_metrics = None
-    sched.defer_block_free = False
-    sched.structured_output_manager.should_advance.return_value = False
-    sched._process_kv_transfer_trigger.return_value = False
-    sched._maybe_decode_pooling_output.return_value = None
-    sched._handle_stopped_request.return_value = True
-    # The whole 3-token prompt ends up cached: 3 - 1 pre-cached = 2 created.
-    sched.kv_cache_manager.estimate_cached_tokens.return_value = 3
-
-    def _free_and_invalidate(req):
-        # Lifecycle guard: freeing releases the KV blocks, after which the
-        # manager reports 0 cached tokens. If finalize ran after
-        # _free_request (the reviewed bug), creation count would compute
-        # against 0 and the assertions below would see 0, not 2.
-        sched.kv_cache_manager.estimate_cached_tokens.return_value = 0
-        return (None, None)
-
-    sched._free_request.side_effect = _free_and_invalidate
-    sched.chunk_transfer_adapter = None
-    sched.finished_req_ids_dict = None
-    sched._new_prompt_len_snapshot = {}
-    return sched
-
-
-def _frame(request: Request):
-    scheduler_output = MagicMock(spec=SchedulerOutput)
-    scheduler_output.num_scheduled_tokens = {request.request_id: 1}
-    scheduler_output.total_num_scheduled_tokens = 1
-    scheduler_output.scheduled_spec_decode_tokens = {}
-    scheduler_output.num_invalid_spec_tokens = 0
-
-    model_runner_output = MagicMock(spec=ModelRunnerOutput)
-    model_runner_output.sampled_token_ids = [[42]]
-    model_runner_output.logprobs = None
-    model_runner_output.prompt_logprobs_dict = {}
-    model_runner_output.pooler_output = None
-    model_runner_output.num_nans_in_logits = None
-    model_runner_output.kv_connector_output = None
-    model_runner_output.cudagraph_stats = None
-    model_runner_output.req_id_to_index = {request.request_id: 0}
-    model_runner_output.routed_experts = None
-    return scheduler_output, model_runner_output
-
-
-def test_ar_scheduler_finalizes_prefill_stats_before_emitting() -> None:
-    request = _make_request()
-    sched = _make_sched(request)
-    sched._update_request_with_output.return_value = ([42], True)
-
-    engine_core_outputs = OmniARScheduler.update_from_output(sched, *_frame(request))
-
-    (eco,) = engine_core_outputs[request.client_index].outputs
-    assert eco.prefill_stats is not None
-    assert eco.prefill_stats.num_cached_tokens == 1
-    assert eco.prefill_stats.num_cache_creation_tokens == 2
-    sched.kv_cache_manager.estimate_cached_tokens.assert_called_once_with(request)
-
-
-def test_generation_scheduler_finalizes_prefill_stats_before_emitting() -> None:
-    request = _make_request()
-    request.num_computed_tokens = len(request.prompt_token_ids)
-    sched = _make_sched(request)
-
-    engine_core_outputs = OmniGenerationScheduler.update_from_output(sched, *_frame(request))
-
-    (eco,) = engine_core_outputs[request.client_index].outputs
-    assert eco.prefill_stats is not None
-    assert eco.prefill_stats.num_cached_tokens == 1
-    assert eco.prefill_stats.num_cache_creation_tokens == 2
-    sched.kv_cache_manager.estimate_cached_tokens.assert_called_once_with(request)
@@ -18,7 +18,7 @@
      "model": "openbmb/MiniCPM-o-4_5",
      "extra_cli_args": [
        "--deploy-config",
-        "vllm_omni/deploy/minicpmo_4_5.yaml",
+        "vllm_omni/deploy/minicpmo_4_5_duplex.yaml",
        "--trust-remote-code"
      ]
    },
@@ -21,6 +21,47 @@
      ]
    },
    "benchmark_params": [
+      {
+        "dataset_name": "random",
+        "backend": "openai-chat-omni",
+        "endpoint": "/v1/chat/completions",
+        "num_prompts": [
+          4,
+          16,
+          32,
+          64,
+          128
+        ],
+        "max_concurrency": [
+          1,
+          4,
+          8,
+          16,
+          32
+        ],
+        "random_input_len": 2500,
+        "random_output_len": 900,
+        "ignore_eos": true,
+        "percentile-metrics": "ttft,tpot,itl,e2el,audio_rtf,audio_ttfp,audio_duration",
+        "baseline": {
+          "H100": {
+            "mean_e2el_ms": [
+              11701.3818,
+              27510.3956,
+              31907.9613,
+              42173.9832,
+              63970.0751
+            ],
+            "mean_audio_rtf": [
+              0.1175,
+              0.1647,
+              0.2003,
+              0.2726,
+              0.4195
+            ]
+          }
+        }
+      },
      {
        "dataset_name": "random-mm",
        "backend": "openai-chat-omni",
@@ -129,6 +170,45 @@
          }
        }
      },
+      {
+        "dataset_name": "random",
+        "backend": "openai-chat-omni",
+        "endpoint": "/v1/chat/completions",
+        "num_prompts": [
+          4,
+          16,
+          32,
+          64,
+          128
+        ],
+        "max_concurrency": [
+          1,
+          4,
+          8,
+          16,
+          32
+        ],
+        "random_input_len": 2500,
+        "random_output_len": 900,
+        "ignore_eos": true,
+        "extra_body": {
+          "modalities": [
+            "text"
+          ]
+        },
+        "percentile-metrics": "ttft,tpot,itl,e2el",
+        "baseline": {
+          "H100": {
+            "mean_e2el_ms": [
+              4354.8945,
+              7672.4248,
+              9861.1687,
+              13086.8865,
+              18716.709
+            ]
+          }
+        }
+      },
      {
        "dataset_name": "random-mm",
        "backend": "openai-chat-omni",
@@ -244,61 +324,5 @@
        }
      }
    ]
-  },
-  {
-    "test_name": "test_qwen3_omni_chunk_cuda",
-    "mark": [
-      {
-        "hardware_marks": {
-          "res": {
-            "cuda": "H100"
-          },
-          "num_cards": 2
-        }
-      },
-      "omni",
-      "slow"
-    ],
-    "server_params": {
-      "model": "Qwen/Qwen3-Omni-30B-A3B-Instruct",
-      "extra_cli_args": [
-        "--async-chunk"
-      ]
-    },
-    "benchmark_params": [
-      {
-        "dataset_name": "random",
-        "backend": "openai-chat-omni",
-        "endpoint": "/v1/chat/completions",
-        "num_prompts": [
-          4,
-          32,
-          128
-        ],
-        "max_concurrency": [
-          1,
-          8,
-          32
-        ],
-        "random_input_len": 100,
-        "random_output_len": 100,
-        "ignore_eos": true,
-        "extra_body": {
-          "modalities": [
-            "text"
-          ]
-        },
-        "percentile-metrics": "ttft,tpot,itl,e2el",
-        "baseline": {
-          "H100": {
-            "mean_e2el_ms": [
-              4354.8945,
-              9861.1687,
-              18716.709
-            ]
-          }
-        }
-      }
-    ]
  }
 ]
@@ -29,12 +29,16 @@
        "endpoint": "/v1/completions",
        "num_prompts": [
          4,
+          16,
          32,
+          64,
          128
        ],
        "max_concurrency": [
          1,
+          4,
          8,
+          16,
          32
        ],
        "random_input_len": 2500,
@@ -50,7 +54,9 @@
          "H100": {
            "mean_e2el_ms": [
              4619.0068,
+              7868.3523,
              9760.6175,
+              13422.3491,
              18007.6918
            ]
          }
@@ -93,6 +99,45 @@
          }
        }
      },
+      {
+        "dataset_name": "random-mm",
+        "backend": "vllm",
+        "model": "Qwen/Qwen3-Omni-30B-A3B-Instruct",
+        "endpoint": "/v1/completions",
+        "num_prompts": [
+          40
+        ],
+        "request_rate": [
+          0.5
+        ],
+        "random_input_len": 100,
+        "random_output_len": 100,
+        "random_range_ratio": 0.0,
+        "ignore_eos": true,
+        "extra_body": {
+          "modalities": [
+            "text"
+          ]
+        },
+        "random_mm_base_items_per_request": 2,
+        "random_mm_num_mm_items_range_ratio": 0.5,
+        "random_mm_limit_mm_per_prompt": {
+          "image": 1,
+          "video": 1
+        },
+        "random_mm_bucket_config": {
+          "(256, 256, 1)": 0.5,
+          "(720, 1280, 2)": 0.5
+        },
+        "percentile-metrics": "ttft,tpot,itl,e2el",
+        "baseline": {
+          "H100": {
+            "mean_e2el_ms": [
+              524.5321
+            ]
+          }
+        }
+      },
      {
        "dataset_name": "random-mm",
        "backend": "vllm",
@@ -74,14 +74,13 @@
      "full_model",
      "diffusion"
    ],
-    "description": "Single-device step execution: sequential 512/1536 plus 512 concurrency sweep. One server (max-num-seqs 8).",
+    "description": "Single-device baseline (no parallelism) with step execution",
    "server_type": "vllm-omni",
    "server_params": {
      "model": "Qwen/Qwen-Image",
      "serve_args": {
        "enable-diffusion-pipeline-profiler": true,
-        "step-execution": true,
-        "max-num-seqs": 8
+        "step-execution": true
      }
    },
    "benchmark_params": [
@@ -120,27 +119,6 @@
            "peak_memory_mb_mean": 64500.0
          }
        }
-      },
-      {
-        "name": "512x512_steps20_high_concurrency",
-        "dataset": "random",
-        "task": "t2i",
-        "width": 512,
-        "height": 512,
-        "num-inference-steps": 20,
-        "num-prompts": [20, 40, 80, 160],
-        "max-concurrency": [1, 2, 4, 8],
-        "warmup-requests": 8,
-        "warmup-concurrency": 8,
-        "warmup-num-inference-steps": 20,
-        "enable-negative-prompt": true,
-        "baseline": {
-          "H100": {
-            "throughput_qps": [0.3937, 0.6606, 0.6188, 0.7752],
-            "latency_mean": [2.5466, 3.0235, 6.3948, 10.1944],
-            "peak_memory_mb_mean": [55149.0, 55150.0, 55153.1458, 55156.325]
-          }
-        }
      }
    ]
  },
@@ -265,5 +243,53 @@
        }
      }
    ]
+  },
+  {
+    "test_name": "test_qwen_image_single_device_step_execution_high_concurrency",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100"
+          },
+          "num_cards": 1
+        }
+      },
+      "full_model",
+      "diffusion"
+    ],
+    "description": "Single-device Qwen-Image step-level execution benchmark at 512x512, 20 steps, concurrency sweep",
+    "server_type": "vllm-omni",
+    "server_params": {
+      "model": "Qwen/Qwen-Image",
+      "serve_args": {
+        "enable-diffusion-pipeline-profiler": true,
+        "step-execution": true,
+        "max-num-seqs": 8
+      }
+    },
+    "benchmark_params": [
+      {
+        "name": "512x512_steps20_high_concurrency",
+        "dataset": "random",
+        "task": "t2i",
+        "width": 512,
+        "height": 512,
+        "num-inference-steps": 20,
+        "num-prompts": [20, 40, 80, 160],
+        "max-concurrency": [1, 2, 4, 8],
+        "warmup-requests": 8,
+        "warmup-concurrency": 8,
+        "warmup-num-inference-steps": 20,
+        "enable-negative-prompt": true,
+        "baseline": {
+            "H100": {
+                "throughput_qps": [0.3937, 0.6606, 0.6188, 0.7752],
+                "latency_mean": [2.5466, 3.0235, 6.3948, 10.1944],
+                "peak_memory_mb_mean": [55149.0, 55150.0, 55153.1458, 55156.325]
+            }
+        }
+      }
+    ]
  }
 ]
@@ -157,8 +157,8 @@ def test_speech_missing_required_fields(omni_server: OmniServer, online_client:
                "ref_audio": None,
                "ref_text": None,
            },
-            ("Invalid voice", "vivian"),
-            id="customvoice_invalid_voice",
+            ("CustomVoice", "does not support"),
+            id="customvoice_task_not_supported",
        ),
        pytest.param(
            {"task_type": "InvalidEnum"}, ("task_type", "literal_error", "CustomVoice"), id="task_type_invalid"
@@ -181,17 +181,13 @@ def test_speech_missing_required_fields(omni_server: OmniServer, online_client:
            ("mutually exclusive", "speaker_embedding", "ref_audio"),
            id="speaker_embedding_with_ref_audio_mutually_exclusive",
        ),
-        pytest.param({"max_new_tokens": 0}, ("max_new_tokens", "greater_than_equal"), id="max_new_tokens_below_min"),
+        pytest.param({"max_new_tokens": 0}, ("max_new_tokens", "least 1"), id="max_new_tokens_below_min"),
        pytest.param(
            {"max_new_tokens": _SPEECH_API_MAX_NEW_TOKENS + 1},
            ("max_new_tokens", "exceed 4096"),
            id="max_new_tokens_above_max",
        ),
-        pytest.param(
-            {"seed": -(2**63) - 1},
-            ("seed", "greater_than_equal", "-9223372036854775808"),
-            id="seed_below_min",
-        ),
+        pytest.param({"seed": -1}, ("seed", "greater_than_equal", "0"), id="seed_negative"),
        pytest.param({"seed": 2**63}, ("seed", "less_than_equal", "9223372036854775807"), id="seed_above_max"),
        pytest.param(
            {"initial_codec_chunk_frames": -1},
@@ -279,9 +275,7 @@ def test_speech_invalid_field_values(
        pytest.param({"input": "", "response_format": "wav"}, ("input", "empty"), id="input_empty"),
        pytest.param({"input": "   ", "response_format": "wav"}, ("input", "empty"), id="input_whitespace_only"),
        pytest.param(
-            {"input": "Hello world.", "max_new_tokens": 0},
-            ("max_new_tokens", "greater_than_equal"),
-            id="max_new_tokens_below_min",
+            {"input": "Hello world.", "max_new_tokens": 0}, ("max_new_tokens", "least 1"), id="max_new_tokens_below_min"
        ),
        pytest.param(
            {
@@ -560,14 +554,14 @@ def test_speech_batch_missing_items(omni_server: OmniServer, online_client: Onli
        pytest.param(
            "batch",
            {"max_new_tokens": 0},
-            ("max_new_tokens", "greater_than_equal"),
+            ("max_new_tokens", "least 1"),
            id="batch_max_new_tokens_below_min",
            marks=_SKIP_ISSUE_3649,
        ),
        pytest.param(
            "item",
            {"max_new_tokens": 0},
-            ("max_new_tokens", "greater_than_equal"),
+            ("max_new_tokens", "least 1"),
            id="item_max_new_tokens_below_min",
            marks=_SKIP_ISSUE_3649,
        ),
@@ -72,9 +72,6 @@ def _chat_completions_request_without_expectations(omni_server: OmniServer, case
        body["top_logprobs"] = 5
    elif case_id == "speaker_unknown":
        body["speaker"] = "zz_invalid_qwen3_omni_chat_speaker_xyz"
-    elif case_id == "audio_format_unsupported":
-        body["modalities"] = ["text", "audio"]
-        body["audio"] = {"voice": "alloy", "format": "aac"}
    else:
        raise AssertionError(f"unknown chat completions invalid case_id {case_id!r}")
    return {"json": body, "timeout": 120}
@@ -122,7 +119,7 @@ def _chat_completions_request_without_expectations(omni_server: OmniServer, case
        pytest.param(
            "response_format_json_schema_incomplete",
            400,
-            ("response_format", "BadRequestError", "json_schema"),
+            ("response_format", "value_error", "json_schema"),
            id="invalid_response_format_json_schema",
        ),
        pytest.param("logprobs_wrong_type", 400, "logprobs", id="logprobs_wrong_type", marks=_SKIP_ISSUE_3649),
@@ -138,12 +135,6 @@ def _chat_completions_request_without_expectations(omni_server: OmniServer, case
            ("Invalid speaker", "Supported"),
            id="speaker_unknown_preset",
        ),
-        pytest.param(
-            "audio_format_unsupported",
-            400,
-            ("Invalid audio format", "aac", "Supported formats"),
-            id="unsupported_audio_format",
-        ),
    ],
 )
@pytest.mark.parametrize("omni_server", _QWEN3_OMNI_SERVER, indirect=True)
@@ -308,91 +308,6 @@ def test_flash_attn_func_preferred_over_varlen():
    print("✓ flash_attn_func forward works correctly!")


-@pytest.mark.skipif(not is_gpu, reason="FlashAttention requires CUDA or XPU")
-@pytest.mark.parametrize("k_len", [40, 256])
-def test_cross_attn_key_padding_vs_sdpa(k_len):
-    """
-    Case 3: Cross-attention with a key-padding mask.
-
-    The mask covers only the key sequence; every query position must attend
-    to the valid keys. FA and SDPA outputs should be very close. k_len=256
-    covers equal Q/K lengths, which must not be mistaken for self-attention,
-    and valid key lengths differ per batch element.
-    """
-    device = torch.device(current_omni_platform.device_type)
-    dtype = torch.bfloat16
-
-    batch_size = 2
-    q_len = 256
-    valid_lens = (17, 29)
-    num_heads = 8
-    head_dim = 64
-
-    fa_impl = FlashAttentionImpl(
-        num_heads=num_heads, head_size=head_dim, softmax_scale=1.0 / (head_dim**0.5), causal=False, role="cross"
-    )
-    sdpa_impl = SDPAImpl(num_heads=num_heads, head_size=head_dim, softmax_scale=1.0 / (head_dim**0.5), causal=False)
-
-    torch.manual_seed(7)
-    query = torch.randn(batch_size, q_len, num_heads, head_dim, device=device, dtype=dtype)
-    key = torch.randn(batch_size, k_len, num_heads, head_dim, device=device, dtype=dtype)
-    value = torch.randn(batch_size, k_len, num_heads, head_dim, device=device, dtype=dtype)
-
-    attn_mask = torch.zeros(batch_size, k_len, dtype=torch.bool, device=device)
-    for i, valid_len in enumerate(valid_lens):
-        attn_mask[i, :valid_len] = True
-    attn_metadata = AttentionMetadata(attn_mask=attn_mask)
-
-    output_fa = fa_impl.forward(query=query, key=key, value=value, attn_metadata=attn_metadata)
-    output_sdpa = sdpa_impl.forward(query=query, key=key, value=value, attn_metadata=attn_metadata)
-
-    max_diff = torch.max(torch.abs(output_fa - output_sdpa)).item()
-    mean_diff = torch.mean(torch.abs(output_fa - output_sdpa)).item()
-
-    print("\n=== Case 3: Cross-Attention Key-Padding FA vs SDPA ===")
-    print(f"Max absolute difference: {max_diff:.6f}")
-    print(f"Mean absolute difference: {mean_diff:.6f}")
-
-    assert max_diff < 0.01, f"Max difference {max_diff} exceeds threshold 0.01"
-    assert mean_diff < 0.001, f"Mean difference {mean_diff} exceeds threshold 0.001"
-
-    print("✓ Case 3 PASSED: FA and SDPA cross-attention outputs are very close!")
-
-
-def test_varlen_masked_routing_by_role(monkeypatch):
-    """The unpad route is picked by role, not Q/K length equality; runs without a GPU."""
-    calls = []
-
-    def fake_varlen_func(q, k, v, **kwargs):
-        calls.append((q.shape[0], kwargs["cu_seqlens_q"], kwargs["cu_seqlens_k"]))
-        return q
-
-    monkeypatch.setattr(fa, "HAS_FLASH_ATTN", True)
-    monkeypatch.setattr(fa, "flash_attn_varlen_func", fake_varlen_func)
-
-    batch_size, seq_len, num_heads, head_dim = 2, 4, 2, 8
-    query = torch.randn(batch_size, seq_len, num_heads, head_dim)
-    metadata = AttentionMetadata(attn_mask=torch.tensor([[True, True, False, False], [True, True, True, False]]))
-
-    cross_impl = FlashAttentionImpl(
-        num_heads=num_heads, head_size=head_dim, softmax_scale=0.5, causal=False, role="cross"
-    )
-    output = cross_impl.forward_cuda(query, query, query, metadata)
-    assert output.shape == query.shape
-    num_q_rows, cu_seqlens_q, cu_seqlens_k = calls[-1]
-    assert num_q_rows == batch_size * seq_len
-    assert cu_seqlens_q.tolist() == [0, 4, 8]
-    assert cu_seqlens_k.tolist() == [0, 2, 5]
-
-    self_impl = FlashAttentionImpl(num_heads=num_heads, head_size=head_dim, softmax_scale=0.5, causal=False)
-    output = self_impl.forward_cuda(query, query, query, metadata)
-    assert output.shape == query.shape
-    num_q_rows, cu_seqlens_q, cu_seqlens_k = calls[-1]
-    assert num_q_rows == 5
-    assert cu_seqlens_q.tolist() == [0, 2, 5]
-    assert cu_seqlens_k.tolist() == [0, 2, 5]
-
-
 def test_piecewise_flash_attn_uses_varlen_fallback(monkeypatch):
    calls = []

@@ -260,7 +260,7 @@ async def compare_single_vs_parallel(
 ) -> None:
    """Run the same prompts sequentially then in parallel and print a comparison."""

-    omni = AsyncOmni(model=model, max_num_seqs=batch_size, diffusion_batch_size=batch_size)
+    omni = AsyncOmni(model=model, diffusion_batch_size=batch_size)
    try:
        await warmup(omni, WARMUP_PROMPTS)
        single_time = await run_single(omni, prompts)
@@ -288,7 +288,7 @@ async def main(model: str, num_prompts: int, mode: str, batch_size: int = 1) ->
        await compare_single_vs_parallel(model, prompts, batch_size=batch_size)
        return

-    omni = AsyncOmni(model=model, max_num_seqs=batch_size, diffusion_batch_size=batch_size)
+    omni = AsyncOmni(model=model, diffusion_batch_size=batch_size)
    try:
        await warmup(omni, WARMUP_PROMPTS)

@@ -524,12 +524,7 @@ if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="E2E diffusion concurrent benchmark / validation")
    parser.add_argument("--model", type=str, required=True, help="Model name or path")
    parser.add_argument("--num-prompts", type=int, default=8, help="Number of prompts to run")
-    parser.add_argument(
-        "--batch-size",
-        type=int,
-        default=1,
-        help="Scheduler in-flight width (--max-num-seqs) and client diffusion_batch_size",
-    )
+    parser.add_argument("--batch-size", type=int, default=1, help="Diffusion batch size (1 = no batching)")
    parser.add_argument(
        "--mode",
        choices=["batch", "single", "compare", "validate"],
@@ -365,10 +365,13 @@ class TestCacheDiTBackend:

    @patch("vllm_omni.diffusion.cache.cachedit.backend.BlockAdapter")
    @patch("vllm_omni.diffusion.cache.cachedit.backend.cache_dit")
-    def test_enable_pipeline_uses_fused_blocks(self, mock_cache_dit, mock_block_adapter):
-        """Generic cache path should pick up ``transformer.fused_blocks``."""
+    def test_enable_dreamid_pipeline_uses_fused_blocks(self, mock_cache_dit, mock_block_adapter):
+        """Test DreamID uses pipeline.transformer for cache enable/refresh.
+
+        NOTE: DreamID no longer has a custom enabler, so this tests against the generic path.
+        """
        mock_pipeline = Mock()
-        mock_pipeline.__class__.__name__ = "FakeFusedBlocksPipeline"
+        mock_pipeline.__class__.__name__ = "DreamIDOmniPipeline"
        mock_pipeline.transformer = Mock()
        mock_pipeline.transformer.fused_blocks = Mock()
        mock_pipeline.transformer._cache_dit_adapter_config = CacheDiTAdapterConfig(
@@ -6,6 +6,7 @@ Model specific tests for CacheDiT enablement.
 """

 import ast
+import sys
 from pathlib import Path
 from unittest.mock import Mock, patch

@@ -24,9 +25,18 @@ from vllm_omni.diffusion.models.longcat_image.longcat_image_transformer import L
 from vllm_omni.diffusion.models.ltx2.ltx2_transformer import LTX2VideoTransformer3DModel
 from vllm_omni.platforms import current_omni_platform

+# NOTE: We patch DreamID Omni's modules here with mocks so that we can import and inspect
+# the class even though the dependency may not be set up correctly; this is ok for these
+# tests because we just inspect it and never initialize the model.
+for mod in ("dreamid_omni", "dreamid_omni.modules", "dreamid_omni.modules.model"):
+    sys.modules.setdefault(mod, Mock())
+# isort: split
+from vllm_omni.diffusion.models.dreamid_omni.fusion import FusionModel as DreamIdOmniModel  # noqa: E402
+
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]

 SEPARATE_CFG_TRANSFORMERS = [
+    DreamIdOmniModel,
    HeliosTransformer3DModel,
    LongCatImageTransformer2DModel,
    Cosmos3VFMTransformer,
@@ -1,6 +1,3 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
 # ruff: noqa: N803, E741
 """Layer-level correctness & performance test for MoT parallel linear layers.

@@ -240,53 +237,6 @@ def _reference_forward(x, text_indices, vae_indices, text_linear, vae_linear):
    return output


-def _assert_gen_expert_parallel_metadata(layer):
-    """The secondary expert must satisfy vLLM's parallel-linear contract."""
-    for attr in (
-        "tp_rank",
-        "tp_size",
-        "input_size",
-        "input_size_per_partition",
-        "output_size",
-        "output_size_per_partition",
-    ):
-        assert getattr(layer.gen_exp, attr) == getattr(layer, attr)
-
-
-def test_mot_gen_expert_parallel_metadata():
-    """Keep secondary experts compatible with vLLM online quantizers."""
-    from vllm.model_executor.layers.quantization.online.fp8 import (
-        _is_tp_sharded,
-    )
-
-    with set_current_vllm_config(VllmConfig()):
-        layers = (
-            MoTQKVParallelLinear(
-                hidden_size=16,
-                head_size=4,
-                total_num_heads=4,
-                total_num_kv_heads=2,
-                bias=False,
-                vae_bias=False,
-                params_dtype=torch.bfloat16,
-                disable_tp=True,
-            ),
-            MoTRowParallelLinear(
-                16,
-                8,
-                bias=False,
-                vae_bias=False,
-                input_is_parallel=True,
-                params_dtype=torch.bfloat16,
-                disable_tp=True,
-            ),
-        )
-
-    for layer in layers:
-        _assert_gen_expert_parallel_metadata(layer)
-        assert _is_tp_sharded(layer.gen_exp) is False
-
-
 def _check_and_report(ref: torch.Tensor, mot: torch.Tensor, tag: str):
    """Compare outputs, print metrics, and assert correctness.

@@ -385,8 +335,6 @@ def test_mot_qkv_parallel(image_num: int, K: int, N: int, dtype: str, bias: bool
            disable_tp=True,
        ).cuda()

-        _assert_gen_expert_parallel_metadata(mot_linear)
-
        assert text_linear.output_size_per_partition == N, (
            f"Expected output_size_per_partition={N}, "
            f"got {text_linear.output_size_per_partition}. "
@@ -475,8 +423,6 @@ def test_mot_o_proj(
            disable_tp=True,
        ).cuda()

-        _assert_gen_expert_parallel_metadata(mot_linear)
-
        _sync_weights(text_linear, vae_linear, mot_linear)

        text_idx, vae_idx, M = _make_indices(image_num, _VAE_CHUNK_SIZE)
@@ -555,13 +501,6 @@ def test_mot_qkv_und_mode(K: int, N: int, dtype: str, bias: bool):
        ).cuda()

        with torch.no_grad():
-            # vLLM linear layers leave weights uninitialized (torch.empty), so
-            # a freshly zeroed GPU page would make both outputs zero and the
-            # cosine-similarity gate degenerate. Seed deterministic values so
-            # und-mode is compared against a meaningful reference.
-            ref_linear.weight.normal_(mean=0.0, std=0.02)
-            if ref_linear.bias is not None:
-                ref_linear.bias.normal_(mean=0.0, std=0.02)
            mot_linear.weight.copy_(ref_linear.weight)
            if bias and ref_linear.bias is not None:
                mot_linear.bias.copy_(ref_linear.bias)
@@ -610,13 +549,6 @@ def test_mot_row_und_mode(K: int, N: int, dtype: str, bias: bool):
        ).cuda()

        with torch.no_grad():
-            # vLLM linear layers leave weights uninitialized (torch.empty), so
-            # a freshly zeroed GPU page would make both outputs zero and the
-            # cosine-similarity gate degenerate. Seed deterministic values so
-            # und-mode is compared against a meaningful reference.
-            ref_linear.weight.normal_(mean=0.0, std=0.02)
-            if ref_linear.bias is not None:
-                ref_linear.bias.normal_(mean=0.0, std=0.02)
            mot_linear.weight.copy_(ref_linear.weight)
            if bias and ref_linear.bias is not None:
                mot_linear.bias.copy_(ref_linear.bias)
@@ -340,97 +340,6 @@ def test_rmsnorm_npu_receives_gamma_with_configured_dtype(monkeypatch: pytest.Mo
    assert captured["epsilon"].item() == pytest.approx(1e-5)


-# ── RMSNorm residual tests ──
-
-
-def test_rmsnorm_matches_native_residual_contract():
-    """The non-NPU path preserves separate residual-add and RMSNorm math."""
-    from vllm_omni.diffusion.layers.norm import RMSNorm
-
-    eps = 1e-6
-    norm = RMSNorm(4, eps=eps, dtype=torch.bfloat16)
-    norm.weight.data.copy_(torch.tensor([1.0, 0.5, 1.5, 2.0], dtype=torch.bfloat16))
-    x = torch.tensor([[1.0, -2.0, 3.0, -4.0]], dtype=torch.bfloat16)
-    residual = torch.tensor([[0.00390625, 0.0078125, -0.0078125, 0.015625]], dtype=torch.bfloat16)
-
-    expected_residual = residual + x
-    expected_fp32 = expected_residual.float()
-    expected_output = expected_fp32 * torch.rsqrt(expected_fp32.square().mean(-1, keepdim=True) + eps)
-    expected_output = (expected_output * norm.weight.float()).to(x.dtype)
-    output, updated_residual = norm.forward_native(x, residual)
-
-    torch.testing.assert_close(updated_residual, expected_residual, atol=0, rtol=0)
-    torch.testing.assert_close(output, expected_output, atol=0, rtol=0)
-
-
-@pytest.mark.parametrize(
-    "forward_name",
-    ["forward_cuda", "forward_hip", "forward_musa", "forward_xpu"],
-)
-def test_rmsnorm_non_npu_residual_delegates_to_native(
-    monkeypatch: pytest.MonkeyPatch,
-    forward_name: str,
-):
-    """Platform wrappers keep residual arithmetic in forward_native."""
-    from vllm_omni.diffusion.layers.norm import RMSNorm
-
-    norm = RMSNorm(4, eps=1e-5, dtype=torch.bfloat16)
-    x = torch.randn(2, 4, dtype=torch.bfloat16)
-    residual = torch.randn_like(x)
-    expected_output = torch.randn_like(x)
-    expected_residual = torch.randn_like(x)
-    captured: dict[str, object] = {}
-
-    def forward_native(native_x: torch.Tensor, native_residual: torch.Tensor | None = None):
-        captured.update(x=native_x, residual=native_residual)
-        return expected_output, expected_residual
-
-    monkeypatch.setattr(norm, "forward_native", forward_native)
-
-    output, updated_residual = getattr(norm, forward_name)(x, residual)
-
-    assert output is expected_output
-    assert updated_residual is expected_residual
-    assert captured["x"] is x
-    assert captured["residual"] is residual
-
-
-def test_rmsnorm_npu_residual_uses_torch_npu_fused_op(monkeypatch: pytest.MonkeyPatch):
-    """NPU keeps the direct fused AddRMSNorm path instead of IR fallback."""
-    from vllm_omni.diffusion.layers.norm import RMSNorm
-
-    captured: dict[str, object] = {}
-    fused_output = torch.randn(2, 4, dtype=torch.bfloat16)
-    fused_residual = torch.randn(2, 4, dtype=torch.bfloat16)
-
-    def npu_add_rms_norm(
-        x: torch.Tensor,
-        residual: torch.Tensor,
-        gamma: torch.Tensor,
-        epsilon: float,
-    ):
-        captured.update(x=x, residual=residual, gamma=gamma, epsilon=epsilon)
-        return fused_output, torch.empty(0), fused_residual
-
-    monkeypatch.setitem(
-        sys.modules,
-        "torch_npu",
-        types.SimpleNamespace(npu_add_rms_norm=npu_add_rms_norm),
-    )
-    norm = RMSNorm(4, eps=1e-5, dtype=torch.bfloat16)
-    x = torch.randn(2, 4, dtype=torch.bfloat16)
-    residual = torch.randn(2, 4, dtype=torch.bfloat16)
-
-    output, updated_residual = norm.forward_npu(x, residual)
-
-    assert output is fused_output
-    assert updated_residual is fused_residual
-    assert captured["x"] is x
-    assert captured["residual"] is residual
-    assert captured["gamma"] is norm.weight
-    assert captured["epsilon"] == 1e-5
-
-
 # ── RMSNorm compile-path regression tests ──


@@ -1,34 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-
-import pytest
-import torch
-
-from vllm_omni.diffusion.layers.norm import RMSNorm
-from vllm_omni.platforms import current_omni_platform
-
-pytestmark = [
-    pytest.mark.core_model,
-    pytest.mark.diffusion,
-    pytest.mark.cuda,
-    pytest.mark.skipif(not current_omni_platform.is_cuda(), reason="CUDA platform required"),
-]
-
-
-def test_rmsnorm_cuda_residual_matches_native_contract() -> None:
-    eps = 1e-6
-    device = torch.device(current_omni_platform.device_type)
-    torch.manual_seed(0)
-    norm = RMSNorm(64, eps=eps, dtype=torch.bfloat16).to(device)
-    x = torch.randn(2, 4, 64, device=device, dtype=torch.bfloat16)
-    residual = torch.randn_like(x)
-    x_before = x.clone()
-    residual_before = residual.clone()
-
-    expected_output, expected_residual = norm.forward_native(x_before, residual_before)
-    output, updated_residual = norm.forward_cuda(x, residual)
-
-    torch.testing.assert_close(updated_residual, expected_residual, atol=0, rtol=0)
-    torch.testing.assert_close(output, expected_output, atol=0, rtol=0)
-    torch.testing.assert_close(x, x_before, atol=0, rtol=0)
-    torch.testing.assert_close(residual, residual_before, atol=0, rtol=0)
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project

 from __future__ import annotations

@@ -89,29 +89,6 @@ def test_diffusion_base_linear_apply_multi_slice():
    assert torch.allclose(out, expected)


-def test_diffusion_lora_buffer_device_persists_across_reallocation(monkeypatch):
-    from vllm.lora.layers.base_linear import BaseLinearLayerWithLoRA
-
-    layer = DiffusionBaseLinearLayerWithLoRA.__new__(DiffusionBaseLinearLayerWithLoRA)
-    torch.nn.Module.__init__(layer)
-    layer.base_layer = torch.nn.Module()
-    layer.n_slices = 1
-    layer.lora_a_stacked = (torch.zeros(2),)
-    layer.lora_b_stacked = (torch.zeros(3),)
-
-    layer._set_diffusion_lora_buffer_device(torch.device("meta"))
-    assert all(tensor.is_meta for tensor in (*layer.lora_a_stacked, *layer.lora_b_stacked))
-
-    def recreate_on_cpu(self, max_loras, lora_config, model_config):
-        self.lora_a_stacked = (torch.zeros(4),)
-        self.lora_b_stacked = (torch.zeros(5),)
-
-    monkeypatch.setattr(BaseLinearLayerWithLoRA, "create_lora_weights", recreate_on_cpu)
-    layer.create_lora_weights(max_loras=1, lora_config=object())
-
-    assert all(tensor.is_meta for tensor in (*layer.lora_a_stacked, *layer.lora_b_stacked))
-
-
 def test_diffusion_base_linear_reset_lora_disables_fast_path(monkeypatch):
    # Verify that after reset_lora(), apply() skips LoRA matmuls even if the
    # LoRA tensors are still allocated and non-empty.
@@ -3,8 +3,6 @@

 from __future__ import annotations

-from types import SimpleNamespace
-
 import pytest
 import torch
 from vllm.lora.lora_weights import LoRALayerWeights
@@ -145,37 +143,6 @@ def test_lora_manager_replace_layers_does_not_rewrap_base_layer(monkeypatch):
    assert replace_calls == ["foo"]


-def test_lora_manager_keeps_dlo_lora_buffers_on_compute_device(monkeypatch):
-    import vllm_omni.diffusion.lora.manager as manager_mod
-
-    class _DLOLoRALayer(DummyBaseLayerWithLoRA):
-        lora_buffer_device = None
-
-        def _set_diffusion_lora_buffer_device(self, device):
-            self.lora_buffer_device = device
-
-    monkeypatch.setattr(manager_mod, "BaseLayerWithLoRA", _DLOLoRALayer)
-    monkeypatch.setattr(
-        manager_mod,
-        "from_layer_diffusion",
-        lambda *, layer, **_kwargs: _DLOLoRALayer(layer),
-    )
-
-    pipeline = torch.nn.Module()
-    pipeline.od_config = SimpleNamespace(enable_distributed_layerwise_offload=True)
-    pipeline.transformer = torch.nn.Module()
-    pipeline.transformer.foo = _FakeLinearBase()
-    manager = DiffusionLoRAManager(
-        pipeline=pipeline,
-        device=torch.device("cpu"),
-        dtype=torch.bfloat16,
-    )
-
-    manager._replace_layers_with_lora(type("_PH", (), {"r": 1})())
-
-    assert pipeline.transformer.foo.lora_buffer_device == torch.device("cpu")
-
-
 def test_lora_manager_replaces_packed_layer_when_targeting_sublayers(monkeypatch):
    import vllm_omni.diffusion.lora.manager as manager_mod

@@ -24,7 +24,6 @@ from vllm_omni.diffusion.model_loader.host_weight_plan import (
    HostWeightPlanResult,
    TensorBinding,
 )
-from vllm_omni.diffusion.model_loader.host_weights import source_identity as source_identity_module
 from vllm_omni.diffusion.models.helios import HeliosPipeline
 from vllm_omni.diffusion.models.host_weight_contract import FinalLayoutModelContract
 from vllm_omni.diffusion.registry import initialize_model
@@ -174,15 +173,6 @@ def test_hwr_cold_publication_and_warm_restore_skip_ordinary_dit_loading(
        str(canonical_root / "model.safetensors"),
    )
    store_root = tmp_path / "hwr-store"
-    hash_calls = 0
-    original_sha256 = source_identity_module._sha256_file
-
-    def counted_sha256(path: Path, state: object) -> str:
-        nonlocal hash_calls
-        hash_calls += 1
-        return original_sha256(path, state)  # type: ignore[arg-type]
-
-    monkeypatch.setattr(source_identity_module, "_sha256_file", counted_sha256)

    def make_loader() -> tuple[DiffusersPipelineLoader, _HWRPipeline]:
        loader = DiffusersPipelineLoader(LoadConfig(), _hwr_config(canonical_root, store_root))
@@ -215,8 +205,6 @@ def test_hwr_cold_publication_and_warm_restore_skip_ordinary_dit_loading(
    assert warm_plan is not None
    assert warm_plan.lease_carrier is not None
    warm_plan.lease_carrier.close()
-    assert hash_calls == 1
-    assert len(tuple((store_root / "source-digests-v1" / "entries").glob("*.json"))) == 1


 def test_hwr_commit_failure_discards_model_and_reloads_without_hwr_or_mmap(tmp_path: Path, monkeypatch):
@@ -249,30 +237,6 @@ def test_hwr_commit_failure_discards_model_and_reloads_without_hwr_or_mmap(tmp_p
    assert loader.take_host_weight_plan() is None


-def test_required_hwr_miss_fails_before_ordinary_loading_or_publication(
-    tmp_path: Path,
-    monkeypatch,
-):
-    canonical_root = tmp_path / "canonical"
-    canonical_root.mkdir()
-    save_file(
-        {"weight": torch.arange(4, dtype=torch.float32).to(torch.bfloat16).reshape(2, 2)},
-        str(canonical_root / "model.safetensors"),
-    )
-    loader = DiffusersPipelineLoader(
-        LoadConfig(),
-        _hwr_config(canonical_root, tmp_path / "empty-store", mode="required"),
-    )
-    pipeline = _HWRPipeline(canonical_root)
-    monkeypatch.setattr(loader, "_init_from_load_format", lambda *args, **kwargs: pipeline)
-
-    with pytest.raises(RuntimeError, match="Host Weight Runtime resolution failed"):
-        loader.load_model(load_device="cpu", device=torch.device("cpu"))
-
-    assert pipeline.load_count == 0
-    assert loader.take_host_weight_plan() is None
-
-
 def _make_dlo_online_quant_config() -> OmniDiffusionConfig:
    return OmniDiffusionConfig(
        model="",
@@ -285,11 +249,10 @@ def _make_dlo_online_quant_config() -> OmniDiffusionConfig:


@pytest.mark.parametrize(
-    ("dist_offload", "use_allgather", "mode"),
+    ("dist_offload", "use_allgather"),
    [
-        (False, False, "preferred"),
-        (True, True, "preferred"),
-        (True, False, "disabled"),
+        (False, False),
+        (True, True),
    ],
 )
 def test_hwr_disabled_for_noneligible_dlo_paths_without_store_interaction(
@@ -297,13 +260,12 @@ def test_hwr_disabled_for_noneligible_dlo_paths_without_store_interaction(
    tmp_path,
    dist_offload,
    use_allgather,
-    mode,
 ):
    """Disabled and AllGather paths must never construct or probe HWR."""
    from vllm_omni.host_weight_runtime import HostWeightRuntime

    root = tmp_path / "must-not-be-touched"
-    loader = DiffusersPipelineLoader(LoadConfig(), _hwr_config("dummy-model", root, mode=mode))
+    loader = DiffusersPipelineLoader(LoadConfig(), _hwr_config("dummy-model", root))
    model = _DummyPipelineModel(source_prefix="transformer.")
    modules = SimpleNamespace(dit_names=("transformer",), dits=(model.transformer,))

@@ -6,8 +6,6 @@ from __future__ import annotations

 import dataclasses
 import gc
-import json
-import threading
 from collections.abc import Sequence
 from pathlib import Path
 from types import SimpleNamespace
@@ -26,12 +24,10 @@ from vllm_omni.diffusion.model_loader.host_weights import (
    FinalLayoutRequest,
    FinalLayoutTensorRestorer,
    ImplementationIdentity,
-    NodeSourceDigestCache,
    PreparedWeightSource,
    WeightSourceKind,
    build_final_layout_identity,
 )
-from vllm_omni.diffusion.model_loader.host_weights import source_identity as source_identity_module
 from vllm_omni.diffusion.model_loader.host_weights.contracts import (
    FINAL_LAYOUT_TENSOR_RESTORER_SCHEMA,
    FinalLayoutArtifactSpec,
@@ -303,83 +299,6 @@ class _FakeH3Attention(nn.Module):
        super().__init__()


-class _FakeFluxLinear(_FakeH3Linear):
-    def __init__(
-        self,
-        *args: object,
-        bias: bool = False,
-        params_dtype: torch.dtype | None = None,
-        total_num_heads: int | None = None,
-        total_num_kv_heads: int | None = None,
-        **kwargs: object,
-    ) -> None:
-        super().__init__(
-            *args,
-            bias=bias,
-            params_dtype=params_dtype,
-            total_num_heads=total_num_heads,
-            total_num_kv_heads=total_num_kv_heads,
-            **kwargs,
-        )
-        self.weight.weight_loader = self._load_weight
-
-    @staticmethod
-    def _load_weight(
-        parameter: nn.Parameter,
-        loaded_weight: torch.Tensor,
-        shard_id: str | None = None,
-    ) -> None:
-        del shard_id
-        parameter.data.copy_(loaded_weight.to(parameter).reshape_as(parameter))
-
-
-class _FakeFluxAttention(nn.Module):
-    def __init__(self, **kwargs: object) -> None:
-        del kwargs
-        super().__init__()
-        self.register_buffer("beta", torch.tensor([0.5]))
-        self.register_buffer("eps", torch.tensor([-1e-6]))
-
-
-class _Flux2KleinPipeline(nn.Module):
-    def __init__(self, transformer: nn.Module) -> None:
-        super().__init__()
-        self.transformer = transformer
-        self.text_encoder = nn.Linear(2, 2, dtype=torch.bfloat16)
-        self.vae = nn.Module()
-        self.vae.register_buffer("gain", torch.tensor([9.0], dtype=torch.float32))
-
-
-def _reduced_flux2_klein(
-    monkeypatch: pytest.MonkeyPatch,
-    *,
-    device: torch.device | str = "cpu",
-) -> nn.Module:
-    from vllm_omni.diffusion.models.flux2_klein import flux2_klein_transformer as flux2
-
-    monkeypatch.setattr(flux2, "ColumnParallelLinear", _FakeFluxLinear)
-    monkeypatch.setattr(flux2, "MergedColumnParallelLinear", _FakeFluxLinear)
-    monkeypatch.setattr(flux2, "QKVParallelLinear", _FakeFluxLinear)
-    monkeypatch.setattr(flux2, "RowParallelLinear", _FakeFluxLinear)
-    monkeypatch.setattr(flux2, "Attention", _FakeFluxAttention)
-
-    transformer = flux2.Flux2Transformer2DModel(
-        patch_size=1,
-        in_channels=8,
-        out_channels=8,
-        num_layers=1,
-        num_single_layers=1,
-        attention_head_dim=8,
-        num_attention_heads=1,
-        joint_attention_dim=8,
-        timestep_guidance_channels=8,
-        mlp_ratio=1.0,
-        axes_dims_rope=(2, 2, 2, 2),
-        guidance_embeds=False,
-    )
-    return transformer.to(device=device, dtype=torch.bfloat16)
-
-
 class _H3Pipeline(nn.Module):
    def __init__(self, transformer: nn.Module) -> None:
        super().__init__()
@@ -461,7 +380,6 @@ def _identity(
    *,
    request: FinalLayoutRequest | None = None,
    policy: FinalLayoutTensorPolicy = FINAL_LAYOUT_BF16_POLICY,
-    source_digest_cache: NodeSourceDigestCache | None = None,
 ) -> FinalLayoutIdentityContext:
    transformer = model.get_submodule("transformer")
    return build_final_layout_identity(
@@ -470,7 +388,6 @@ def _identity(
        prepared_sources=(source,),
        request=request or _request(),
        policy=policy,
-        source_digest_cache=source_digest_cache,
    )


@@ -647,131 +564,6 @@ def test_source_identity_resolves_longest_prefix_and_rejects_ties(tmp_path: Path
    assert exc_info.value.code is FinalLayoutContractCode.SOURCE_COVERAGE_INVALID


-def test_node_source_digest_cache_reuses_recovers_and_invalidates(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    model = _TinyPipeline()
-    source = _prepared_source(tmp_path)
-    cache_root = tmp_path / "store"
-    calls = 0
-    original_sha256 = source_identity_module._sha256_file
-
-    def counted_sha256(path: Path, state: object) -> str:
-        nonlocal calls
-        calls += 1
-        return original_sha256(path, state)  # type: ignore[arg-type]
-
-    monkeypatch.setattr(source_identity_module, "_sha256_file", counted_sha256)
-    first = _identity(
-        model,
-        source,
-        source_digest_cache=NodeSourceDigestCache(cache_root, timeout_seconds=1.0),
-    )
-    second = _identity(
-        model,
-        source,
-        source_digest_cache=NodeSourceDigestCache(cache_root, timeout_seconds=1.0),
-    )
-
-    assert second.identity == first.identity
-    assert calls == 1
-
-    cache_entry = next((cache_root / "source-digests-v1" / "entries").glob("*.json"))
-    cache_entry.write_text("not-json", encoding="utf-8")
-    recovered = _identity(
-        model,
-        source,
-        source_digest_cache=NodeSourceDigestCache(cache_root, timeout_seconds=1.0),
-    )
-    assert recovered.identity == first.identity
-    assert calls == 2
-
-    cache_document = json.loads(cache_entry.read_text(encoding="utf-8"))
-    cache_document["content_id"] = f"sha256:{'0' * 64}"
-    cache_entry.write_text(json.dumps(cache_document), encoding="utf-8")
-    checksum_recovered = _identity(
-        model,
-        source,
-        source_digest_cache=NodeSourceDigestCache(cache_root, timeout_seconds=1.0),
-    )
-    assert checksum_recovered.identity == first.identity
-    assert calls == 3
-
-    source.weight_files[0].write_bytes(b"changed-canonical-source-with-a-new-size")
-    changed = _identity(
-        model,
-        source,
-        source_digest_cache=NodeSourceDigestCache(cache_root, timeout_seconds=1.0),
-    )
-    assert changed.identity != first.identity
-    assert calls == 4
-
-
-def test_source_identity_hashes_checkpoint_shards_in_parallel(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    model = _TinyPipeline()
-    source = _prepared_source(tmp_path)
-    second_file = source.resolved_root / "model-00002.safetensors"
-    second_file.write_bytes(b"second-checkpoint-shard")
-    source = dataclasses.replace(source, weight_files=(*source.weight_files, second_file))
-    barrier = threading.Barrier(2)
-    thread_ids: set[int] = set()
-    thread_ids_lock = threading.Lock()
-    original_sha256 = source_identity_module._sha256_file
-
-    def synchronized_sha256(path: Path, state: object) -> str:
-        with thread_ids_lock:
-            thread_ids.add(threading.get_ident())
-        barrier.wait(timeout=5)
-        return original_sha256(path, state)  # type: ignore[arg-type]
-
-    monkeypatch.setattr(source_identity_module, "_sha256_file", synchronized_sha256)
-    _identity(model, source)
-
-    assert len(thread_ids) == 2
-
-
-def test_source_digest_cache_lock_timeout_falls_back_to_direct_hashing(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    model = _TinyPipeline()
-    source = _prepared_source(tmp_path)
-    cache = NodeSourceDigestCache(tmp_path / "store", timeout_seconds=0.01)
-
-    def unavailable_lock(*_args: object, **_kwargs: object) -> object:
-        raise source_identity_module.FileLockTimeoutError("busy")
-
-    monkeypatch.setattr(source_identity_module, "FileLock", unavailable_lock)
-    context = _identity(model, source, source_digest_cache=cache)
-
-    assert context.identity.source.revision.startswith("content-")
-    assert not tuple(cache.entries.glob("*.json"))
-
-
-def test_source_digest_cache_directory_failure_falls_back_to_direct_hashing(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    model = _TinyPipeline()
-    source = _prepared_source(tmp_path)
-    original_mkdir = Path.mkdir
-
-    def failing_cache_mkdir(path: Path, *args: object, **kwargs: object) -> None:
-        if "source-digests-v1" in path.parts:
-            raise OSError("injected cache directory failure")
-        original_mkdir(path, *args, **kwargs)  # type: ignore[arg-type]
-
-    monkeypatch.setattr(Path, "mkdir", failing_cache_mkdir)
-    cache = NodeSourceDigestCache(tmp_path / "store", timeout_seconds=0.01)
-    context = _identity(model, source, source_digest_cache=cache)
-
-    assert context.identity.source.revision.startswith("content-")
-
-
 def test_local_hex_named_symlink_target_is_content_hashed_across_startups(tmp_path: Path) -> None:
    model = _TinyPipeline()
    source_root = tmp_path / "local-symlink-source"
@@ -1277,152 +1069,3 @@ def test_minimax_h3_declares_the_final_layout_restore_contract() -> None:
    assert contract.implementation_id == "minimax-h3-dit"
    assert callable(MiniMaxH3DiTModel.validate_restored_host_weights)
    assert "data_parallel" not in FinalLayoutRequest.__dataclass_fields__
-
-
-def test_reduced_flux2_klein_declares_complete_final_layout_contract(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    from vllm_omni.diffusion.models.flux2_klein.flux2_klein_transformer import (
-        Flux2Transformer2DModel,
-    )
-
-    transformer = _reduced_flux2_klein(monkeypatch)
-    pipeline = _Flux2KleinPipeline(transformer)
-    source = _prepared_source(tmp_path, directory="flux2-klein-source")
-    context = _identity(pipeline, source)
-    targets = collect_final_layout_targets(
-        pipeline,
-        (("transformer", transformer),),
-        policy=FINAL_LAYOUT_BF16_POLICY,
-        require_materialized=True,
-    )
-    target_names = {target.name for target in targets}
-
-    contract = Flux2Transformer2DModel.host_weight_restore_contract
-    assert isinstance(contract, FinalLayoutModelContract)
-    assert contract.schema == FINAL_LAYOUT_TENSOR_MODEL_CONTRACT_SCHEMA
-    assert contract.implementation_id == "flux2-klein-dit"
-    assert contract.version == "1"
-    assert context.model_contracts == (contract,)
-    assert transformer.stacked_params_mapping == [
-        (".to_qkv.", ".to_q.", "q"),
-        (".to_qkv.", ".to_k.", "k"),
-        (".to_qkv.", ".to_v.", "v"),
-        (".add_kv_proj", ".add_q_proj", "q"),
-        (".add_kv_proj", ".add_k_proj", "k"),
-        (".add_kv_proj", ".add_v_proj", "v"),
-    ]
-    loaded = transformer.load_weights(
-        [
-            ("transformer_blocks.0.attn.to_q.weight", torch.tensor([1.0], dtype=torch.bfloat16)),
-            ("transformer_blocks.0.attn.add_q_proj.weight", torch.tensor([2.0], dtype=torch.bfloat16)),
-            (
-                "single_transformer_blocks.0.attn.to_qkv_mlp_proj.weight",
-                torch.tensor([3.0], dtype=torch.bfloat16),
-            ),
-        ]
-    )
-    assert loaded == {
-        "transformer_blocks.0.attn.to_qkv.weight",
-        "transformer_blocks.0.attn.add_kv_proj.weight",
-        "single_transformer_blocks.0.attn.to_qkv_mlp_proj.weight",
-    }
-    assert any(name.startswith("transformer.transformer_blocks.0.") for name in target_names)
-    assert any(name.startswith("transformer.single_transformer_blocks.0.") for name in target_names)
-    assert "transformer.transformer_blocks.0.attn.to_qkv.weight" in target_names
-    assert "transformer.transformer_blocks.0.attn.add_kv_proj.weight" in target_names
-    assert "transformer.single_transformer_blocks.0.attn.to_qkv_mlp_proj.weight" in target_names
-    assert "transformer.transformer_blocks.0.attn.attn.beta" in target_names
-    assert "transformer.transformer_blocks.0.attn.attn.eps" in target_names
-    assert all("text_encoder" not in name and "vae" not in name for name in target_names)
-    transformer.validate_restored_host_weights()
-
-
-def test_flux2_klein_restore_validator_rejects_non_ready_state(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    transformer = _reduced_flux2_klein(monkeypatch)
-
-    mapping = transformer.stacked_params_mapping
-    transformer.stacked_params_mapping = None
-    with pytest.raises(ValueError, match="packed QKV mapping"):
-        transformer.validate_restored_host_weights()
-    transformer.stacked_params_mapping = mapping
-
-    weight = transformer.x_embedder.weight
-    weight.data = weight.data.float()
-    with pytest.raises(ValueError, match="must stay bf16"):
-        transformer.validate_restored_host_weights()
-    weight.data = weight.data.to(torch.bfloat16)
-
-    weight.data = weight.data.T
-    with pytest.raises(ValueError, match="contiguous strided layout"):
-        transformer.validate_restored_host_weights()
-    weight.data = weight.data.contiguous()
-
-    attention = transformer.transformer_blocks[0].attn.attn
-    attention._non_persistent_buffers_set.add("beta")
-    with pytest.raises(ValueError, match="must be persistent"):
-        transformer.validate_restored_host_weights()
-    attention._non_persistent_buffers_set.remove("beta")
-
-    attention.beta.data = attention.beta.data.float()
-    with pytest.raises(ValueError, match="scalar bf16"):
-        transformer.validate_restored_host_weights()
-
-
-def test_flux2_klein_publication_restore_fallback_and_teardown(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    source = _prepared_source(tmp_path, directory="flux2-klein-source")
-    cold_transformer = _reduced_flux2_klein(monkeypatch)
-    cold_model = _Flux2KleinPipeline(cold_transformer)
-    with torch.no_grad():
-        for index, parameter in enumerate(cold_transformer.parameters(), start=1):
-            parameter.fill_(index)
-        for name, buffer in cold_transformer.named_buffers():
-            if name.endswith((".beta", ".eps")):
-                buffer.fill_(0.5 if name.endswith(".beta") else -1e-6)
-
-    context = _identity(cold_model, source)
-    runtime = _runtime(tmp_path / "flux2-klein-store")
-    miss = runtime.resolve(context.identity)
-    assert miss.report.outcome is ResolutionOutcome.CANONICAL_FALLBACK
-
-    producer = FinalLayoutBF16Producer(
-        context,
-        cold_model,
-        (("transformer", cold_transformer),),
-        max_shard_bytes=64,
-    )
-    publication = runtime.publish_after_load(context.identity, producer=producer)
-    assert publication.outcome is PostLoadPublicationOutcome.PUBLISHED
-
-    warm_transformer = _reduced_flux2_klein(monkeypatch, device="meta")
-    warm_model = _Flux2KleinPipeline(warm_transformer)
-    warm_context = _identity(warm_model, source)
-    assert warm_context.identity == context.identity
-    hit = runtime.resolve(warm_context.identity)
-    assert hit.report.outcome is ResolutionOutcome.LOCAL_HIT
-    assert hit.lease is not None
-
-    plan = FinalLayoutTensorRestorer(warm_context).plan_restore(warm_model, hit.lease)
-    assert all(tensor.is_meta for name, tensor in warm_model.named_parameters() if name.startswith("transformer."))
-    plan.commit()
-    warm_transformer.validate_restored_host_weights()
-
-    cold_tensors = dict(cold_model.named_parameters()) | dict(cold_model.named_buffers())
-    warm_tensors = dict(warm_model.named_parameters()) | dict(warm_model.named_buffers())
-    for name in warm_context.tensor_names:
-        assert torch.equal(warm_tensors[name], cold_tensors[name])
-        assert warm_tensors[name].untyped_storage().data_ptr() == hit.lease.tensors[name].untyped_storage().data_ptr()
-    assert warm_transformer.stacked_params_mapping == cold_transformer.stacked_params_mapping
-
-    del warm_tensors, warm_model, warm_transformer, plan
-    gc.collect()
-    hit.lease.close()
-    assert hit.lease.closed
-    assert isinstance(runtime.store, FilesystemHostWeightStore)
-    assert runtime.store.cleanup(context.identity) is None
@@ -0,0 +1,27 @@
+import pytest
+import torch.nn as nn
+
+pytest.importorskip("dreamid_omni.modules.model")
+
+from vllm_omni.diffusion.models.dreamid_omni.fusion import FusionModel
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_dreamid_omni_exposes_hsdp_shard_conditions_for_fused_blocks():
+    model = object.__new__(FusionModel)
+    nn.Module.__init__(model)
+    model.fused_blocks = nn.ModuleList([nn.Linear(4, 4) for _ in range(2)])
+    model.attn = nn.Identity()
+
+    conditions = getattr(model, "_hsdp_shard_conditions", None)
+
+    assert conditions is not None
+    assert len(conditions) == 1
+
+    matched = []
+    for name, module in model.named_modules():
+        if any(cond(name, module) for cond in conditions):
+            matched.append(name)
+
+    assert matched == ["fused_blocks.0", "fused_blocks.1"]
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project

 from __future__ import annotations

@@ -245,7 +245,7 @@ else:
        [sys.executable, "-c", script, str(_MODULE_PATH), str(tmp_path)],
        capture_output=True,
        text=True,
-        timeout=30,
+        timeout=3,
        check=False,
    )

@@ -11,31 +11,6 @@ import torch
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]


-def test_ltx_base_vocoder_keeps_native_dtype(monkeypatch):
-    import vllm_omni.diffusion.models.ltx2.ltx2_runtime as ltx_runtime
-
-    class FakeBaseVocoder(torch.nn.Module):
-        def __init__(self):
-            super().__init__()
-            self.input_dtype = None
-
-        def forward(self, value):
-            self.input_dtype = value.dtype
-            return value
-
-    monkeypatch.setattr(
-        ltx_runtime.torch,
-        "autocast",
-        lambda **_kwargs: (_ for _ in ()).throw(AssertionError("base vocoder must not use autocast")),
-    )
-    vocoder = FakeBaseVocoder()
-
-    output = ltx_runtime._run_ltx_vocoder(vocoder, torch.ones(1, dtype=torch.bfloat16))
-
-    assert vocoder.input_dtype == torch.bfloat16
-    assert output.dtype == torch.bfloat16
-
-
 class TestLTXOutputRank:
    @pytest.mark.parametrize(
        ("distributed_vae_state", "expected_decode_calls"),
@@ -1,48 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-
-"""CUDA regression tests for LTX-2 BWE vocoder precision."""
-
-import pytest
-import torch
-
-from tests.helpers.mark import hardware_test
-
-pytestmark = [pytest.mark.core_model, pytest.mark.diffusion]
-
-
-class _BWEConvVocoder(torch.nn.Module):
-    def __init__(self):
-        super().__init__()
-        self.conv = torch.nn.Conv1d(
-            1,
-            1,
-            kernel_size=1,
-            bias=False,
-            device="cuda",
-            dtype=torch.bfloat16,
-        )
-        self.bwe_generator = torch.nn.Identity()
-        self.input_dtype = None
-        self.conv_output_dtype = None
-
-    def forward(self, value):
-        self.input_dtype = value.dtype
-        output = self.conv(value)
-        self.conv_output_dtype = output.dtype
-        return output
-
-
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
-def test_ltx_bwe_vocoder_runs_real_cuda_autocast_in_fp32():
-    from vllm_omni.diffusion.models.ltx2.ltx2_runtime import _run_ltx_vocoder
-
-    vocoder = _BWEConvVocoder()
-    generated_mel = torch.ones((1, 1, 4), device="cuda", dtype=torch.bfloat16)
-
-    output = _run_ltx_vocoder(vocoder, generated_mel)
-
-    assert next(vocoder.parameters()).dtype == torch.bfloat16
-    assert vocoder.input_dtype == torch.float32
-    assert vocoder.conv_output_dtype == torch.float32
-    assert output.dtype == torch.bfloat16
@@ -964,80 +964,6 @@ def test_minimax_h3_advertises_the_official_ref2va_image_limit():
    assert get_diffusion_model_metadata("MiniMaxH3Pipeline").max_multimodal_image_inputs == 9


-def test_text_attention_routes_local_gqa_heads_through_sdpa_helper(monkeypatch):
-    from vllm_omni.diffusion.models.minimax_h3 import encoder as encoder_module
-
-    class FakeEncoderGroup:
-        rank_in_group = 0
-        world_size = 2
-
-        def all_reduce(self, tensor):
-            del tensor
-
-    config = SimpleNamespace(
-        hidden_size=8,
-        num_attention_heads=4,
-        num_key_value_heads=2,
-        head_dim=2,
-        rms_norm_eps=1e-6,
-    )
-    with (
-        patch("vllm.model_executor.parameter.get_tensor_model_parallel_rank", return_value=0),
-        patch("vllm.model_executor.parameter.get_tensor_model_parallel_world_size", return_value=1),
-    ):
-        attention = encoder_module.MiniMaxH3Qwen3VLTextAttention(FakeEncoderGroup(), config, torch.float32)
-    # This CPU contract test only needs projection shapes and head reshaping.
-    # Avoid dispatching platform-specific norm and linear kernels (for example,
-    # rocm_unquantized_gemm when the test suite is collected on ROCm).
-    attention.q_norm = nn.Identity()
-    attention.k_norm = nn.Identity()
-    with torch.no_grad():
-        attention.qkv_proj.weight.zero_()
-    attention.o_proj = nn.Linear(
-        attention.qkv_proj.local_num_heads * attention.head_dim,
-        config.hidden_size,
-        bias=False,
-    )
-    attn_call = {}
-
-    def fake_attention(query, key, value):
-        attn_call.update(query_shape=query.shape, key_shape=key.shape, value_shape=value.shape)
-        return query
-
-    monkeypatch.setattr(encoder_module, "_scaled_dot_product_attention", fake_attention)
-    hidden_states = torch.randn(1, 3, config.hidden_size)
-    cos = torch.ones(1, 3, config.head_dim)
-    sin = torch.zeros_like(cos)
-
-    output = attention(hidden_states, (cos, sin))
-
-    assert attn_call["query_shape"] == (1, config.num_attention_heads // 2, 3, config.head_dim)
-    assert attn_call["key_shape"] == (1, config.num_key_value_heads // 2, 3, config.head_dim)
-    assert attn_call["value_shape"] == (1, config.num_key_value_heads // 2, 3, config.head_dim)
-    assert output.shape == hidden_states.shape
-
-
-def test_text_attention_sdpa_helper_preserves_expanded_kv_fallback(monkeypatch):
-    from vllm_omni.diffusion.models.minimax_h3 import encoder as encoder_module
-
-    sdpa_call = {}
-
-    def fake_sdpa(query, key, value, **kwargs):
-        sdpa_call.update(query_shape=query.shape, key_shape=key.shape, value_shape=value.shape, kwargs=kwargs)
-        return query
-
-    monkeypatch.setattr(torch.nn.functional, "scaled_dot_product_attention", fake_sdpa)
-    output = encoder_module._scaled_dot_product_attention(
-        torch.randn(1, 4, 3, 8),
-        torch.randn(1, 2, 3, 8),
-        torch.randn(1, 2, 3, 8),
-    )
-
-    assert sdpa_call["query_shape"] == sdpa_call["key_shape"] == sdpa_call["value_shape"] == (1, 4, 3, 8)
-    assert sdpa_call["kwargs"] == {"dropout_p": 0.0, "is_causal": True}
-    assert output.shape == (1, 4, 3, 8)
-
-
 def test_encoder_forward_uses_hook_compatible_encode_entrypoint():
    from vllm_omni.diffusion.models.minimax_h3.encoder import (
        MiniMaxH3Qwen3VLEncoder,
@@ -197,6 +197,7 @@ def test_h3_turbo_rejects_wrong_alpha_and_ref2va(tmp_path):
    [
        "model-level CPU offload (--enable-cpu-offload)",
        "layerwise offload (--enable-layerwise-offload)",
+        "distributed layerwise offload (--enable-distributed-layerwise-offload)",
    ],
 )
 def test_h3_turbo_rejects_offload_modes(tmp_path, offload_mode):
@@ -213,38 +214,6 @@ def test_h3_turbo_rejects_offload_modes(tmp_path, offload_mode):
        )


-def test_h3_turbo_allows_distributed_layerwise_offload(monkeypatch):
-    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
-    from vllm_omni.diffusion.models.minimax_h3 import (
-        pipeline_minimax_h3 as pipeline_module,
-    )
-
-    pipeline = object.__new__(MiniMaxH3Pipeline)
-    torch.nn.Module.__init__(pipeline)
-    pipeline.partition = "fl2va"
-    pipeline._turbo_lora_adapter_ids = set()
-    pipeline.od_config = SimpleNamespace(
-        enable_cpu_offload=False,
-        enable_layerwise_offload=False,
-        enable_distributed_layerwise_offload=True,
-    )
-    captured = {}
-
-    def load_turbo(**kwargs):
-        captured.update(kwargs)
-        return object(), object()
-
-    monkeypatch.setattr(pipeline_module, "load_minimax_h3_turbo_lora", load_turbo)
-    loaded = pipeline._load_diffusion_lora_adapter(
-        lora_request=_request("turbo"),
-        lora_path="turbo",
-        dtype=torch.bfloat16,
-    )
-
-    assert loaded is not None
-    assert captured["unsupported_offload_mode"] is None
-
-
 def test_h3_turbo_accepts_only_the_declared_v1_artifact(tmp_path):
    unsupported = tmp_path / "minimax_h3_fl2v_turbo_8step_v1.0_bf16.safetensors"
    _write_tiny_turbo(unsupported)
@@ -1,132 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-
-import pytest
-import torch
-import torch.nn.functional as F
-
-from vllm_omni.platforms import current_omni_platform
-
-pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.npu]
-
-
-@pytest.mark.skipif(not current_omni_platform.is_npu(), reason="requires Ascend NPU")
-def test_minimax_h3_npu_sdpa_patch_is_independent_and_idempotent(monkeypatch) -> None:
-    from vllm_omni.diffusion.models.minimax_h3 import encoder as encoder_module
-    from vllm_omni.platforms.npu.models import minimax_h3 as npu_minimax_h3
-
-    def sdpa_sentinel(query, key, value):
-        del key, value
-        return query
-
-    def rope_sentinel(q, k, cos, sin):
-        del cos, sin
-        return q, k
-
-    monkeypatch.setattr(npu_minimax_h3, "_ROPE_PATCHED", False)
-    monkeypatch.setattr(npu_minimax_h3, "_SDPA_PATCHED", False)
-    monkeypatch.setattr(encoder_module, "_apply_rotary_pos_emb", rope_sentinel)
-    monkeypatch.setattr(encoder_module, "_scaled_dot_product_attention", sdpa_sentinel)
-
-    npu_minimax_h3.apply_minimax_h3_qwen3vl_sdpa_patch()
-
-    assert encoder_module._scaled_dot_product_attention is npu_minimax_h3._scaled_dot_product_attention_npu
-    assert encoder_module._apply_rotary_pos_emb is rope_sentinel
-    assert not npu_minimax_h3._ROPE_PATCHED
-    assert npu_minimax_h3._SDPA_PATCHED
-
-    monkeypatch.setattr(encoder_module, "_scaled_dot_product_attention", sdpa_sentinel)
-    npu_minimax_h3.apply_minimax_h3_qwen3vl_sdpa_patch()
-
-    assert encoder_module._scaled_dot_product_attention is sdpa_sentinel
-
-
-@pytest.mark.skipif(not current_omni_platform.is_npu(), reason="requires Ascend NPU")
-@pytest.mark.parametrize(
-    ("num_heads", "num_kv_heads", "expected_enable_gqa"),
-    [(2, 2, False), (4, 2, True)],
-)
-def test_minimax_h3_npu_sdpa_preserves_compressed_heads_and_selects_gqa(
-    monkeypatch,
-    num_heads: int,
-    num_kv_heads: int,
-    expected_enable_gqa: bool,
-) -> None:
-    from vllm_omni.platforms.npu.models import minimax_h3 as npu_minimax_h3
-
-    captured: dict[str, object] = {}
-
-    def fake_sdpa(query, key, value, **kwargs):
-        captured.update(query=query, key=key, value=value, kwargs=kwargs)
-        return query
-
-    monkeypatch.setattr(F, "scaled_dot_product_attention", fake_sdpa)
-    query = torch.randn(1, num_heads, 3, 8)
-    key = torch.randn(1, num_kv_heads, 3, 8)
-    value = torch.randn_like(key)
-
-    output = npu_minimax_h3._scaled_dot_product_attention_npu(query, key, value)
-
-    assert captured["query"] is query
-    assert captured["key"] is key
-    assert captured["value"] is value
-    assert captured["kwargs"] == {
-        "dropout_p": 0.0,
-        "is_causal": True,
-        "enable_gqa": expected_enable_gqa,
-    }
-    assert output is query
-
-
-@pytest.mark.skipif(not current_omni_platform.is_npu(), reason="requires Ascend NPU")
-@pytest.mark.parametrize(
-    ("num_heads", "num_key_heads", "num_value_heads", "message"),
-    [
-        (4, 2, 1, "key and value to have the same number of heads"),
-        (4, 0, 0, "at least one KV head"),
-        (3, 2, 2, "query heads to be a multiple of KV heads"),
-    ],
-)
-def test_minimax_h3_npu_sdpa_rejects_invalid_head_configurations(
-    num_heads: int,
-    num_key_heads: int,
-    num_value_heads: int,
-    message: str,
-) -> None:
-    from vllm_omni.platforms.npu.models import minimax_h3 as npu_minimax_h3
-
-    query = torch.randn(1, num_heads, 3, 8)
-    key = torch.randn(1, num_key_heads, 3, 8)
-    value = torch.randn(1, num_value_heads, 3, 8)
-
-    with pytest.raises(ValueError, match=message):
-        npu_minimax_h3._scaled_dot_product_attention_npu(query, key, value)
-
-
-@pytest.mark.skipif(not current_omni_platform.is_npu(), reason="requires Ascend NPU")
-def test_minimax_h3_npu_causal_gqa_matches_expanded_kv() -> None:
-    """Exercise the real torch-npu causal GQA operator."""
-    from vllm_omni.platforms.npu.models import minimax_h3 as npu_minimax_h3
-
-    torch.manual_seed(0)
-    batch_size, seq_len = 1, 16
-    num_heads, num_kv_heads, head_size = 8, 2, 128
-    device = torch.device("npu")
-    dtype = torch.bfloat16
-
-    query = torch.randn(batch_size, num_heads, seq_len, head_size, device=device, dtype=dtype)
-    key = torch.randn(batch_size, num_kv_heads, seq_len, head_size, device=device, dtype=dtype)
-    value = torch.randn_like(key)
-
-    actual = npu_minimax_h3._scaled_dot_product_attention_npu(query, key, value)
-
-    repeat_num = num_heads // num_kv_heads
-    expected = F.scaled_dot_product_attention(
-        query,
-        key.repeat_interleave(repeat_num, dim=1),
-        value.repeat_interleave(repeat_num, dim=1),
-        dropout_p=0.0,
-        is_causal=True,
-    )
-
-    torch.testing.assert_close(actual, expected, atol=2e-2, rtol=2e-2)
@@ -6,38 +6,7 @@ import torch

 from vllm_omni.platforms import current_omni_platform

-pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.npu]
-
-
-@pytest.mark.skipif(not current_omni_platform.is_npu(), reason="requires Ascend NPU")
-def test_qwen3_vl_npu_rope_patch_is_independent_and_idempotent(monkeypatch) -> None:
-    from vllm_omni.diffusion.models.minimax_h3 import encoder as encoder_module
-    from vllm_omni.platforms.npu.models import minimax_h3 as npu_minimax_h3
-
-    def rope_sentinel(q, k, cos, sin):
-        del cos, sin
-        return q, k
-
-    def sdpa_sentinel(query, key, value):
-        del key, value
-        return query
-
-    monkeypatch.setattr(npu_minimax_h3, "_ROPE_PATCHED", False)
-    monkeypatch.setattr(npu_minimax_h3, "_SDPA_PATCHED", False)
-    monkeypatch.setattr(encoder_module, "_apply_rotary_pos_emb", rope_sentinel)
-    monkeypatch.setattr(encoder_module, "_scaled_dot_product_attention", sdpa_sentinel)
-
-    npu_minimax_h3.apply_minimax_h3_qwen3vl_patch()
-
-    assert encoder_module._apply_rotary_pos_emb is npu_minimax_h3._apply_rotary_pos_emb_npu
-    assert encoder_module._scaled_dot_product_attention is sdpa_sentinel
-    assert npu_minimax_h3._ROPE_PATCHED
-    assert not npu_minimax_h3._SDPA_PATCHED
-
-    monkeypatch.setattr(encoder_module, "_apply_rotary_pos_emb", rope_sentinel)
-    npu_minimax_h3.apply_minimax_h3_qwen3vl_patch()
-
-    assert encoder_module._apply_rotary_pos_emb is rope_sentinel
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion]


@pytest.mark.skipif(not current_omni_platform.is_npu(), reason="requires Ascend NPU")
@@ -1,20 +1,10 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project

-from types import SimpleNamespace
-from unittest.mock import patch
-
-import pytest
 import torch
-import torch.nn as nn

 from vllm_omni.diffusion.layers.norm import RMSNorm
-from vllm_omni.diffusion.models.minimax_h3.encoder import (
-    MiniMaxH3Qwen3VLRMSNorm,
-    MiniMaxH3Qwen3VLTextDecoderLayer,
-)
-
-pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+from vllm_omni.diffusion.models.minimax_h3.encoder import MiniMaxH3Qwen3VLRMSNorm


 def test_qwen3_vl_rmsnorm_uses_common_fused_rmsnorm_contract() -> None:
@@ -34,43 +24,3 @@ def test_qwen3_vl_rmsnorm_uses_common_fused_rmsnorm_contract() -> None:
    assert norm.weight.dtype == torch.bfloat16
    assert set(norm.state_dict()) == {"weight"}
    torch.testing.assert_close(norm.forward_native(x), expected, atol=0, rtol=0)
-
-
-def test_qwen3_vl_decoder_preserves_post_attention_residual_contract() -> None:
-    class ConstantAttention(nn.Module):
-        def forward(self, hidden_states, position_embeddings):
-            del position_embeddings
-            return torch.full_like(hidden_states, 2.0)
-
-    config = SimpleNamespace(
-        hidden_size=8,
-        intermediate_size=16,
-        num_attention_heads=4,
-        num_key_value_heads=2,
-        head_dim=2,
-        rms_norm_eps=1e-6,
-    )
-    group = SimpleNamespace(rank_in_group=0, world_size=1)
-    with (
-        patch("vllm.model_executor.parameter.get_tensor_model_parallel_rank", return_value=0),
-        patch("vllm.model_executor.parameter.get_tensor_model_parallel_world_size", return_value=1),
-    ):
-        layer = MiniMaxH3Qwen3VLTextDecoderLayer(group, config, torch.float32)
-    layer.input_layernorm = nn.Identity()
-    layer.self_attn = ConstantAttention()
-    layer.mlp = nn.Identity()
-
-    hidden_states = torch.arange(24, dtype=torch.float32).reshape(1, 3, 8)
-    attention_output = torch.full_like(hidden_states, 2.0)
-    expected_residual = hidden_states + attention_output
-    expected_normalized = RMSNorm.forward_native(layer.post_attention_layernorm, expected_residual)
-
-    with patch.object(
-        layer.post_attention_layernorm,
-        "forward",
-        wraps=layer.post_attention_layernorm.forward_native,
-    ):
-        output = layer(hidden_states, (torch.empty(0), torch.empty(0)))
-
-    assert isinstance(layer.post_attention_layernorm, MiniMaxH3Qwen3VLRMSNorm)
-    torch.testing.assert_close(output, expected_residual + expected_normalized)
@@ -1,250 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from __future__ import annotations
-
-import ctypes
-from types import SimpleNamespace
-
-import pytest
-import torch
-
-import vllm_omni.diffusion.offloader.cuda_host_registration as registration_module
-from vllm_omni.diffusion.offloader.cuda_host_registration import (
-    CudaHostRegistration,
-    _coalesce_ranges,
-    _mapped_regions,
-)
-from vllm_omni.diffusion.offloader.host_registration import (
-    HostRegistrationBudgetError,
-    HostRegistrationCleanupError,
-    HostRegistrationError,
-    register_host_mappings,
-)
-from vllm_omni.host_weight_runtime import MappedHostRegion
-
-pytestmark = [pytest.mark.diffusion, pytest.mark.cpu, pytest.mark.core_model]
-
-
-class _FakeRuntime:
-    def __init__(
-        self,
-        register_results: list[int | Exception],
-        unregister_results: list[int | Exception] | None = None,
-        *,
-        read_only_supported: bool = True,
-        attribute_result: int = 0,
-    ) -> None:
-        self._register_results = iter(register_results)
-        self._unregister_results = iter(unregister_results or [])
-        self._read_only_supported = read_only_supported
-        self._attribute_result = attribute_result
-        self.attribute_queries: list[tuple[int, int]] = []
-        self.registered: list[tuple[int, int, int]] = []
-        self.unregistered: list[int] = []
-
-    def cudaDeviceGetAttribute(self, value, attribute: int, device: int) -> int:
-        self.attribute_queries.append((attribute, device))
-        ctypes.cast(value, ctypes.POINTER(ctypes.c_int)).contents.value = int(self._read_only_supported)
-        return self._attribute_result
-
-    def cudaHostRegister(self, pointer: int, size: int, flags: int) -> int:
-        self.registered.append((pointer, size, flags))
-        result = next(self._register_results)
-        if isinstance(result, Exception):
-            raise result
-        return result
-
-    def cudaHostUnregister(self, pointer: int) -> int:
-        self.unregistered.append(pointer)
-        result = next(self._unregister_results, 0)
-        if isinstance(result, Exception):
-            raise result
-        return result
-
-    @staticmethod
-    def cudaGetErrorString(error: int) -> str:
-        return f"error-{error}"
-
-
-def _region(
-    file_name: str,
-    address: int,
-    length: int,
-    *,
-    read_only: bool = True,
-) -> MappedHostRegion:
-    return MappedHostRegion(file_name=file_name, address=address, length=length, read_only=read_only)
-
-
-@pytest.fixture(autouse=True)
-def _cuda_runtime_prerequisites(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setattr(registration_module.torch.cuda, "is_available", lambda: True)
-    monkeypatch.setattr(registration_module.torch.accelerator, "current_device_index", lambda: 0)
-
-
-def test_platform_dispatch_and_unsupported_device(monkeypatch: pytest.MonkeyPatch) -> None:
-    sentinel = object()
-    regions = (_region("weights", 0x1000, 4096),)
-
-    def create(actual_regions, *, max_bytes):
-        assert actual_regions is regions
-        assert max_bytes == 4096
-        return sentinel
-
-    monkeypatch.setattr(CudaHostRegistration, "create", staticmethod(create))
-    assert register_host_mappings(regions, device=torch.device("cuda"), max_bytes=4096) is sentinel
-    with pytest.raises(HostRegistrationError, match="not supported on cpu"):
-        register_host_mappings(regions, device=torch.device("cpu"), max_bytes=None)
-
-
-def test_ranges_align_per_file_without_merging_adjacent_files() -> None:
-    assert _coalesce_ranges([(0x1003, 4096), (0x2800, 1024)], page_size=4096) == (
-        registration_module._AddressRange(0x1000, 0x3000),
-    )
-    assert _mapped_regions(
-        (
-            _region("first.safetensors", 0x1000, 4096),
-            _region("second.safetensors", 0x2000, 4096),
-        )
-    ) == (
-        registration_module._AddressRange(0x1000, 0x2000),
-        registration_module._AddressRange(0x2000, 0x3000),
-    )
-
-
-def test_registration_rejects_writable_or_over_budget_before_cuda(monkeypatch: pytest.MonkeyPatch) -> None:
-    runtime = _FakeRuntime([0])
-    monkeypatch.setattr(registration_module.torch.cuda, "cudart", lambda: runtime)
-
-    with pytest.raises(HostRegistrationError, match="is writable"):
-        CudaHostRegistration.create((_region("weights", 0x1000, 1, read_only=False),), max_bytes=None)
-    with pytest.raises(HostRegistrationBudgetError, match="exceeding"):
-        CudaHostRegistration.create((_region("weights", 0x1003, 4096),), max_bytes=4096)
-    assert runtime.registered == []
-
-
-def test_registration_requires_read_only_capability(monkeypatch: pytest.MonkeyPatch) -> None:
-    runtime = _FakeRuntime([0], read_only_supported=False)
-    monkeypatch.setattr(registration_module.torch.cuda, "cudart", lambda: runtime)
-
-    with pytest.raises(HostRegistrationError, match="does not support read-only"):
-        CudaHostRegistration.create((_region("weights", 0x1000, 4096),), max_bytes=None)
-    assert runtime.attribute_queries == [
-        (registration_module._CUDA_DEVICE_ATTRIBUTE_HOST_REGISTER_READ_ONLY_SUPPORTED, 0)
-    ]
-    assert runtime.registered == []
-
-
-def test_capability_error_is_consumed_before_fallback(monkeypatch: pytest.MonkeyPatch) -> None:
-    runtime = _FakeRuntime([0], attribute_result=7)
-    monkeypatch.setattr(registration_module.torch.cuda, "cudart", lambda: runtime)
-    consumed: list[tuple[object, int]] = []
-    monkeypatch.setattr(
-        registration_module,
-        "_consume_last_cuda_error",
-        lambda actual_runtime, error: consumed.append((actual_runtime, error)),
-    )
-
-    with pytest.raises(HostRegistrationError, match="error-7"):
-        CudaHostRegistration.create((_region("weights", 0x1000, 4096),), max_bytes=None)
-    assert consumed == [(runtime, 7)]
-
-
-def test_partial_registration_rolls_back(monkeypatch: pytest.MonkeyPatch) -> None:
-    runtime = _FakeRuntime([0, 7])
-    monkeypatch.setattr(registration_module.torch.cuda, "cudart", lambda: runtime)
-    monkeypatch.setattr(registration_module, "_consume_last_cuda_error", lambda _runtime, _error: None)
-
-    with pytest.raises(HostRegistrationError, match="error-7"):
-        CudaHostRegistration.create(
-            (
-                _region("first", 0x1000, 4096),
-                _region("second", 0x9000, 4096),
-            ),
-            max_bytes=None,
-        )
-    assert runtime.unregistered == [0x1000]
-
-
-def test_failed_rollback_exposes_active_registration_for_retry(monkeypatch: pytest.MonkeyPatch) -> None:
-    runtime = _FakeRuntime([0, 7], unregister_results=[9, 0])
-    monkeypatch.setattr(registration_module.torch.cuda, "cudart", lambda: runtime)
-    monkeypatch.setattr(registration_module, "_consume_last_cuda_error", lambda _runtime, _error: None)
-
-    with pytest.raises(HostRegistrationCleanupError, match="rollback errors") as error:
-        CudaHostRegistration.create(
-            (
-                _region("first", 0x1000, 4096),
-                _region("second", 0x9000, 4096),
-            ),
-            max_bytes=None,
-        )
-    registration = error.value.active_registration
-    assert registration is not None
-    assert registration.close() == ()
-    assert runtime.unregistered == [0x1000, 0x1000]
-
-
-def test_successful_registration_retries_failed_close(monkeypatch: pytest.MonkeyPatch) -> None:
-    runtime = _FakeRuntime([0], unregister_results=[9, 0])
-    monkeypatch.setattr(registration_module.torch.cuda, "cudart", lambda: runtime)
-    monkeypatch.setattr(registration_module, "_consume_last_cuda_error", lambda _runtime, _error: None)
-    registration = CudaHostRegistration.create((_region("weights", 0x1003, 1),), max_bytes=None)
-
-    assert registration.total_bytes == 4096
-    assert registration.region_count == 1
-    assert registration.close() == ("cudaHostUnregister(0x1000) failed: error-9",)
-    assert registration.close() == ()
-    assert runtime.unregistered == [0x1000, 0x1000]
-
-
-@pytest.mark.parametrize("pending_error", [0, 801])
-def test_consume_last_cuda_error_accepts_cleared_or_matching_state(
-    monkeypatch: pytest.MonkeyPatch,
-    pending_error: int,
-) -> None:
-    runtime = SimpleNamespace(cudaGetLastError=lambda: pending_error)
-    monkeypatch.setattr(
-        registration_module.ctypes,
-        "CDLL",
-        lambda _name: pytest.fail("the cudart handle should provide cudaGetLastError"),
-    )
-
-    registration_module._consume_last_cuda_error(runtime, 801)
-
-
-def test_consume_last_cuda_error_falls_back_to_global_symbol(monkeypatch: pytest.MonkeyPatch) -> None:
-    global_runtime = SimpleNamespace(cudaGetLastError=lambda: 801)
-    monkeypatch.setattr(registration_module.ctypes, "CDLL", lambda _name: global_runtime)
-
-    registration_module._consume_last_cuda_error(SimpleNamespace(), 801)
-
-
-def test_clean_rollback_remains_recoverable_when_error_state_cannot_be_cleared(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    runtime = _FakeRuntime([0, 7])
-    monkeypatch.setattr(runtime, "cudaGetLastError", None, raising=False)
-    monkeypatch.setattr(registration_module.torch.cuda, "cudart", lambda: runtime)
-
-    def missing_global_symbol(_name: object) -> None:
-        raise OSError("cudart symbols are local")
-
-    monkeypatch.setattr(
-        registration_module.ctypes,
-        "CDLL",
-        missing_global_symbol,
-    )
-
-    with pytest.raises(HostRegistrationError, match="cannot clear") as error:
-        CudaHostRegistration.create(
-            (
-                _region("first", 0x1000, 4096),
-                _region("second", 0x9000, 4096),
-            ),
-            max_bytes=None,
-        )
-
-    assert not isinstance(error.value, HostRegistrationCleanupError)
-    assert runtime.unregistered == [0x1000]
@@ -5,7 +5,6 @@

 import gc
 import json
-import weakref
 from contextlib import contextmanager
 from types import SimpleNamespace

@@ -18,7 +17,6 @@ from torch.distributed.tensor import DeviceMesh, DTensor, Replicate

 import vllm_omni.diffusion.offloader.distributed_layerwise_backend as dist_backend_module
 from tests.helpers.runtime import get_distributed_init_method
-from vllm_omni.diffusion.data import validate_dlo_host_registration_options
 from vllm_omni.diffusion.model_loader.host_weight_plan import (
    HostWeightPlan,
    TensorBinding,
@@ -35,17 +33,12 @@ from vllm_omni.diffusion.offloader.distributed_layerwise_backend import (
    DistributedLayerwiseOffloadHook,
    PinnedResidentLayerGroup,
 )
-from vllm_omni.diffusion.offloader.host_registration import (
-    HostRegistrationCleanupError,
-    HostRegistrationError,
-)
 from vllm_omni.diffusion.offloader.module_residency import PinnedModuleStager
 from vllm_omni.diffusion.offloader.offload_plan import (
    OffloadPlan,
    get_offload_plan,
 )
 from vllm_omni.diffusion.offloader.startup import OffloadStartupState, attach_offload_startup_state
-from vllm_omni.host_weight_runtime import MappedHostRegion
 from vllm_omni.platforms import current_omni_platform

 pytestmark = [pytest.mark.diffusion, pytest.mark.cpu, pytest.mark.core_model]
@@ -710,15 +703,11 @@ class _HWRPipeline(nn.Module):


 class _FakeHostWeightLease:
-    def __init__(self, resolution_id: str, events: list[str] | None = None):
+    def __init__(self, resolution_id: str):
        self.closed = False
        self.provenance = SimpleNamespace(resolution_id=resolution_id)
-        self.mapped_regions = (MappedHostRegion("weights.safetensors", 0x1000, 4096),)
-        self._events = events

    def close(self):
-        if self._events is not None:
-            self._events.append("lease")
        self.closed = True


@@ -768,206 +757,6 @@ def _hwr_backend():
    return _HWRPipeline(), backend, carrier, lease


-def test_registered_mmap_hook_bypasses_host_staging(patched_offload_runtime):
-    current_block = nn.Linear(2, 2, bias=False)
-    next_block = nn.Linear(2, 2, bias=False)
-    expected = torch.arange(4, dtype=torch.float32).view(2, 2)
-    next_block.weight.data.copy_(expected)
-    hook = DistributedLayerwiseOffloadHook(
-        next_block=next_block,
-        device=torch.device("cpu"),
-        dp_group=None,
-        dp_size=1,
-        rank=0,
-        pin_memory=False,
-        rank_local_mmap=True,
-    )
-    hook.initialize_hook(current_block)
-    hook.registered_mmap = True
-    hook._stage_mmap_sources = lambda _slot: pytest.fail("registered mmap must bypass host staging")  # type: ignore[method-assign]
-
-    hook.prefetch_layer(slot=0, non_blocking=True)
-
-    assert torch.equal(next_block.weight, expected)
-
-
-def test_registered_mmap_resident_group_bypasses_host_staging(patched_offload_runtime):
-    block = nn.Linear(2, 2, bias=False)
-    expected = torch.arange(4, dtype=torch.float32).view(2, 2)
-    block.weight.data.copy_(expected)
-    group = PinnedResidentLayerGroup(
-        [block],
-        device=torch.device("cpu"),
-        copy_stream=DummyStream(),
-        pin_memory=False,
-        rank_local_mmap=True,
-    )
-    group.registered_mmap = True
-    group._cpu_staging_buffers.clear()
-
-    group.load()
-
-    assert torch.equal(block.weight, expected)
-
-
-def test_hwr_registration_uses_transport_budget(
-    monkeypatch: pytest.MonkeyPatch,
-    patched_offload_runtime,
-):
-    dist_backend_module._ACTIVE_HWR_REGISTRATIONS.clear()
-    plan, _, lease = _fake_hwr_plan()
-    backend = DistributedLayerwiseOffloadBackend(
-        OffloadConfig(
-            strategy=OffloadStrategy.DISTRIBUTED_LAYER_WISE,
-            pin_cpu_memory=True,
-            dp_size=1,
-            dlo_use_allgather=False,
-            dlo_host_registration_limit_gib=1.5,
-        ),
-        torch.device("cuda"),
-        host_weight_plan=plan,
-    )
-    backend._host_weight_lease = lease  # type: ignore[assignment]
-    calls: list[tuple[object, int | None]] = []
-
-    class Registration:
-        total_bytes = 4096
-        region_count = 1
-
-        @staticmethod
-        def close() -> tuple[str, ...]:
-            return ()
-
-    def register(regions, *, device, max_bytes):
-        assert device == torch.device("cuda")
-        calls.append((regions, max_bytes))
-        return Registration()
-
-    monkeypatch.setattr(dist_backend_module, "register_host_mappings", register)
-    pinned_source = SimpleNamespace(numel=lambda: 1, is_pinned=lambda: True)
-
-    assert backend._try_register_hwr_mmap((pinned_source,))  # type: ignore[arg-type]
-    assert calls == [(lease.mapped_regions, int(1.5 * 1024**3))]
-    assert dist_backend_module._ACTIVE_HWR_REGISTRATIONS == [(backend._host_registration, lease)]
-
-    backend._release_registered_mmap()
-
-    assert dist_backend_module._ACTIVE_HWR_REGISTRATIONS == []
-
-
-def test_hwr_registration_budget_validation_is_transport_scoped():
-    assert (
-        validate_dlo_host_registration_options(
-            limit_gib=1.5,
-            enable_dlo=True,
-            use_allgather=False,
-            hwr_mode="preferred",
-        )
-        == 1.5
-    )
-    invalid = (
-        dict(limit_gib=-1, enable_dlo=True, use_allgather=False, hwr_mode="preferred"),
-        dict(limit_gib=float("inf"), enable_dlo=True, use_allgather=False, hwr_mode="preferred"),
-        dict(limit_gib=1, enable_dlo=False, use_allgather=False, hwr_mode="preferred"),
-        dict(limit_gib=1, enable_dlo=True, use_allgather=True, hwr_mode="preferred"),
-        dict(limit_gib=1, enable_dlo=True, use_allgather=False, hwr_mode="disabled"),
-    )
-    for options in invalid:
-        with pytest.raises(ValueError):
-            validate_dlo_host_registration_options(**options)
-
-
-def test_unregistration_precedes_lease_close_and_retries_failures(
-    monkeypatch: pytest.MonkeyPatch,
-    patched_offload_runtime,
-):
-    dist_backend_module._ACTIVE_HWR_REGISTRATIONS.clear()
-    events: list[str] = []
-    responses = iter([("busy",), ()])
-
-    class Registration:
-        @staticmethod
-        def close() -> tuple[str, ...]:
-            events.append("unregister")
-            return next(responses)
-
-    backend = DistributedLayerwiseOffloadBackend(
-        OffloadConfig(
-            strategy=OffloadStrategy.DISTRIBUTED_LAYER_WISE,
-            pin_cpu_memory=True,
-            dp_size=1,
-            dlo_use_allgather=False,
-        ),
-        torch.device("cpu"),
-    )
-    lease = _FakeHostWeightLease("retry", events)
-    backend._host_weight_lease = lease  # type: ignore[assignment]
-    backend._host_registration = Registration()
-    backend._using_rank_local_mmap = True
-    backend._using_registered_mmap = True
-    backend.enabled = True
-    monkeypatch.setattr(current_omni_platform, "synchronize", lambda: None)
-
-    with pytest.raises(HostRegistrationCleanupError, match="failed to unregister"):
-        backend.disable()
-    assert not lease.closed
-    assert backend._host_registration is not None
-    assert dist_backend_module._ACTIVE_HWR_REGISTRATIONS == [(backend._host_registration, lease)]
-
-    backend.disable()
-
-    assert lease.closed
-    assert backend._host_registration is None
-    assert dist_backend_module._ACTIVE_HWR_REGISTRATIONS == []
-    assert events == ["unregister", "unregister", "lease"]
-
-
-def test_failed_unregistration_retains_lease_after_backend_is_dropped(
-    monkeypatch: pytest.MonkeyPatch,
-    patched_offload_runtime,
-):
-    events: list[str] = []
-
-    class Registration:
-        @staticmethod
-        def close() -> tuple[str, ...]:
-            events.append("unregister")
-            return ("busy",)
-
-    dist_backend_module._ACTIVE_HWR_REGISTRATIONS.clear()
-    backend = DistributedLayerwiseOffloadBackend(
-        OffloadConfig(
-            strategy=OffloadStrategy.DISTRIBUTED_LAYER_WISE,
-            pin_cpu_memory=True,
-            dp_size=1,
-            dlo_use_allgather=False,
-        ),
-        torch.device("cpu"),
-    )
-    lease = _FakeHostWeightLease("retained", events)
-    registration = Registration()
-    backend._host_weight_lease = lease  # type: ignore[assignment]
-    backend._host_registration = registration
-    backend._using_rank_local_mmap = True
-    backend.enabled = True
-    monkeypatch.setattr(current_omni_platform, "synchronize", lambda: None)
-    lease_ref = weakref.ref(lease)
-
-    with pytest.raises(HostRegistrationCleanupError, match="failed to unregister"):
-        backend.disable()
-    del backend
-    del lease
-    gc.collect()
-
-    retained_lease = dist_backend_module._ACTIVE_HWR_REGISTRATIONS[0][1]
-    assert dist_backend_module._ACTIVE_HWR_REGISTRATIONS == [(registration, retained_lease)]
-    assert lease_ref() is retained_lease
-    assert not retained_lease.closed
-
-    dist_backend_module._ACTIVE_HWR_REGISTRATIONS.clear()
-    retained_lease.close()
-
-
 class _MultiBlockModel(nn.Module):
    _layerwise_offload_blocks_attrs = ["transformer_blocks", "single_transformer_blocks"]

@@ -1131,51 +920,6 @@ class TestMmapWeightLoading:
        backend.disable()
        assert lease.closed

-    def test_hwr_registration_failure_falls_back_to_bounded_staging(
-        self,
-        monkeypatch,
-        patched_offload_runtime,
-    ):
-        plan, carrier, lease = _fake_hwr_plan("hwr-registration-fallback")
-        backend = DistributedLayerwiseOffloadBackend(
-            OffloadConfig(
-                strategy=OffloadStrategy.DISTRIBUTED_LAYER_WISE,
-                pin_cpu_memory=True,
-                dp_size=1,
-                dlo_use_allgather=False,
-            ),
-            torch.device("cpu"),
-            host_weight_plan=plan,
-        )
-        pipeline = _HWRPipeline()
-        original_staging_allocator = backend._allocate_shared_cpu_staging_buffers
-
-        def fail_registration(*args, **kwargs):
-            del args, kwargs
-            raise HostRegistrationError("registration unavailable in CPU test")
-
-        def allocate_unpinned_staging(hooks, resident_group=None):
-            # Registration selection still observes pin_cpu_memory=True. The
-            # CPU-only test avoids asking the host for CUDA-pinned allocations.
-            for hook in hooks:
-                hook.pin_memory = False
-            return original_staging_allocator(hooks, resident_group)
-
-        monkeypatch.setattr(dist_backend_module, "register_host_mappings", fail_registration)
-        monkeypatch.setattr(backend, "_allocate_shared_cpu_staging_buffers", allocate_unpinned_staging)
-
-        backend.enable(pipeline)
-
-        assert carrier.taken
-        assert backend._using_rank_local_mmap
-        assert not backend._using_registered_mmap
-        assert backend._host_registration is None
-        assert all(len(hook.cpu_staging_buffers) == 2 for group in backend._all_hook_groups for hook in group)
-        assert not lease.closed
-
-        backend.disable()
-        assert lease.closed
-
    def test_hwr_backend_failure_drains_partial_setup_before_lease_close(
        self,
        monkeypatch,
@@ -2183,9 +1927,8 @@ class TestDynamicSlotTracking:
                prev_idx = (i - 1) % num_blocks

                # Dynamic slot tracking: read from prev's prefetched slot
-                prefetched_slot = prefetched_slots[prev_idx]
-                if prefetched_slot is not None:
-                    current_slots[i] = prefetched_slot
+                if prefetched_slots[prev_idx] is not None:
+                    current_slots[i] = prefetched_slots[prev_idx]

                read_slot = current_slots[i]

@@ -1,146 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from unittest.mock import Mock
-
-import pytest
-import torch
-from vllm.model_executor.layers.linear import (
-    LinearBase,
-    UnquantizedLinearMethod,
-)
-
-from vllm_omni.quantization import svdquant_config
-from vllm_omni.quantization.factory import (
-    SUPPORTED_QUANTIZATION_METHODS,
-    build_quant_config,
-)
-from vllm_omni.quantization.svdquant_config import (
-    DiffusionSVDQuantConfig,
-    DiffusionSVDQuantLinearMethod,
-)
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
-
-
-def test_config_from_checkpoint_dict() -> None:
-    config = DiffusionSVDQuantConfig.from_config(
-        {
-            "rank": 32,
-            "precision": "nvfp4",
-            "act_unsigned": False,
-            "modules_to_not_convert": ["blocks.0.adaln_proj.linear"],
-        }
-    )
-
-    assert config.rank == 32
-    assert config.precision == "nvfp4"
-    assert config.modules_to_not_convert == ["blocks.0.adaln_proj.linear"]
-    assert config.get_supported_act_dtypes() == [torch.bfloat16]
-
-
-@pytest.mark.parametrize(
-    ("kwargs", "message"),
-    [
-        ({"rank": 0}, "rank must be positive"),
-        ({"precision": "int4"}, "NVFP4 checkpoints only"),
-        ({"act_unsigned": True}, "unsigned activations"),
-    ],
-)
-def test_config_rejects_unsupported_phase1_options(
-    kwargs: dict[str, object],
-    message: str,
-) -> None:
-    with pytest.raises(ValueError, match=message):
-        DiffusionSVDQuantConfig(**kwargs)
-
-
-def test_factory_builds_svdquant_with_extra_checkpoint_fields() -> None:
-    config = build_quant_config(
-        {
-            "quant_method": "svdquant",
-            "rank": 16,
-            "precision": "nvfp4",
-            "w4a16_modules": ["adaln_proj.linear"],
-            "w4a16_group_size": 64,
-        }
-    )
-
-    assert isinstance(config, DiffusionSVDQuantConfig)
-    assert config.rank == 16
-    assert "svdquant" in SUPPORTED_QUANTIZATION_METHODS
-
-
-def test_skipped_and_non_linear_modules_remain_unquantized() -> None:
-    config = DiffusionSVDQuantConfig(modules_to_not_convert=["blocks.0.adaln_proj.linear"])
-    linear = Mock(spec=LinearBase)
-
-    assert isinstance(
-        config.get_quant_method(linear, "blocks.0.adaln_proj.linear"),
-        UnquantizedLinearMethod,
-    )
-    assert config.get_quant_method(torch.nn.ReLU(), "blocks.0.act") is None
-
-
-def test_linear_method_creates_canonical_partitioned_weights(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setattr(svdquant_config, "_assert_supported", lambda: None)
-    method = DiffusionSVDQuantLinearMethod(DiffusionSVDQuantConfig(rank=32))
-    layer = torch.nn.Module()
-
-    method.create_weights(
-        layer,
-        input_size_per_partition=128,
-        output_partition_sizes=[64, 64],
-        input_size=128,
-        output_size=128,
-        params_dtype=torch.bfloat16,
-    )
-
-    assert layer.qweight.shape == (128, 64)
-    assert layer.qweight.dtype == torch.int8
-    assert layer.wscales.shape == (8, 128)
-    assert layer.wscales.dtype == torch.float8_e4m3fn
-    assert layer.proj_down.shape == (128, 32)
-    assert layer.proj_up.shape == (128, 32)
-    assert layer.smooth_factor.shape == (128,)
-    assert layer.wcscales.shape == (128,)
-    assert layer.wtscale.shape == (1,)
-
-    assert layer.qweight.input_dim == 1
-    assert layer.qweight.output_dim == 0
-    assert layer.wscales.input_dim == 0
-    assert layer.wscales.output_dim == 1
-    assert layer.proj_down.input_dim == 0
-    assert layer.proj_up.output_dim == 0
-    assert layer.wcscales.output_dim == 0
-
-
-def test_linear_method_rejects_misaligned_input_partition(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setattr(svdquant_config, "_assert_supported", lambda: None)
-    method = DiffusionSVDQuantLinearMethod(DiffusionSVDQuantConfig())
-
-    with pytest.raises(ValueError, match="divisible by the block size 16"):
-        method.create_weights(
-            torch.nn.Module(),
-            input_size_per_partition=24,
-            output_partition_sizes=[32],
-            input_size=24,
-            output_size=32,
-            params_dtype=torch.bfloat16,
-        )
-
-
-def test_active_linear_uses_svdquant_method(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setattr(svdquant_config, "_assert_supported", lambda: None)
-    config = DiffusionSVDQuantConfig()
-    linear = Mock(spec=LinearBase)
-
-    method = config.get_quant_method(linear, "blocks.0.attn.out_proj")
-
-    assert isinstance(method, DiffusionSVDQuantLinearMethod)
@@ -1,168 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from types import SimpleNamespace
-
-import pytest
-import torch
-
-from vllm_omni.quantization import svdquant_config as svdquant
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
-
-
-class _FakeNvfp4Kernel:
-    def __init__(self, base_weight: torch.Tensor | None = None) -> None:
-        self.base_weight = base_weight
-        self.processed = False
-        self.last_input: torch.Tensor | None = None
-
-    def process_weights_after_loading(self, layer: torch.nn.Module) -> None:
-        del layer
-        self.processed = True
-
-    def apply_weights(
-        self,
-        layer: torch.nn.Module,
-        x: torch.Tensor,
-        bias: torch.Tensor | None = None,
-    ) -> torch.Tensor:
-        del layer
-        assert bias is None
-        assert self.base_weight is not None
-        self.last_input = x.clone()
-        return torch.mm(x, self.base_weight)
-
-
-def _register_parameter(
-    layer: torch.nn.Module,
-    name: str,
-    value: torch.Tensor,
-) -> None:
-    layer.register_parameter(
-        name,
-        torch.nn.Parameter(value, requires_grad=False),
-    )
-
-
-def test_supports_only_validated_datacenter_blackwell() -> None:
-    assert not svdquant._supports_capability(SimpleNamespace(major=10, minor=0))
-    assert svdquant._supports_capability(SimpleNamespace(major=10, minor=3))
-    assert not svdquant._supports_capability(SimpleNamespace(major=11, minor=0))
-    assert not svdquant._supports_capability(SimpleNamespace(major=12, minor=0))
-    assert not svdquant._supports_capability(None)
-
-
-def test_rejects_nvfp4_backend_with_incompatible_layer_contract(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    svdquant._nvfp4_kernel.cache_clear()
-    monkeypatch.setattr(
-        svdquant,
-        "init_nvfp4_linear_kernel",
-        lambda: _FakeNvfp4Kernel(),
-    )
-
-    with pytest.raises(RuntimeError, match="incompatible with the SVDQuant checkpoint"):
-        svdquant._nvfp4_kernel()
-
-    svdquant._nvfp4_kernel.cache_clear()
-
-
-def test_prepare_weights_uses_existing_nvfp4_layout_contract(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    kernel = _FakeNvfp4Kernel()
-    monkeypatch.setattr(svdquant, "_assert_supported", lambda: None)
-    monkeypatch.setattr(svdquant, "_nvfp4_kernel", lambda: kernel)
-    method = svdquant.DiffusionSVDQuantLinearMethod(svdquant.DiffusionSVDQuantConfig())
-    layer = torch.nn.Module()
-    qweight = torch.arange(16, dtype=torch.int8).reshape(4, 4)
-    wscales = torch.arange(8, dtype=torch.float32).to(torch.float8_e4m3fn).reshape(2, 4)
-    _register_parameter(layer, "qweight", qweight)
-    _register_parameter(layer, "wscales", wscales)
-    _register_parameter(layer, "wtscale", torch.tensor([2.0], dtype=torch.bfloat16))
-    _register_parameter(
-        layer,
-        "wcscales",
-        torch.tensor([1.0, 2.0, 3.0, 4.0], dtype=torch.bfloat16),
-    )
-
-    method.process_weights_after_loading(layer)
-
-    assert kernel.processed
-    assert not hasattr(layer, "qweight")
-    assert not hasattr(layer, "wscales")
-    assert layer.weight.dtype == torch.uint8
-    assert torch.equal(layer.weight.view(torch.int8), qweight)
-    assert torch.equal(layer.weight_scale, wscales.transpose(0, 1))
-    torch.testing.assert_close(layer.alpha, torch.tensor([2.0]))
-    assert layer.input_global_scale_inv.dtype == torch.float32
-    assert layer.output_channel_scale.shape == (4,)
-
-
-def test_prepare_weights_drops_identity_output_scale(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    kernel = _FakeNvfp4Kernel()
-    monkeypatch.setattr(svdquant, "_assert_supported", lambda: None)
-    monkeypatch.setattr(svdquant, "_nvfp4_kernel", lambda: kernel)
-    method = svdquant.DiffusionSVDQuantLinearMethod(svdquant.DiffusionSVDQuantConfig())
-    layer = torch.nn.Module()
-    _register_parameter(layer, "qweight", torch.zeros(4, 4, dtype=torch.int8))
-    _register_parameter(
-        layer,
-        "wscales",
-        torch.ones(2, 4, dtype=torch.float8_e4m3fn),
-    )
-    _register_parameter(layer, "wtscale", torch.ones(1, dtype=torch.bfloat16))
-    _register_parameter(layer, "wcscales", torch.ones(4, dtype=torch.bfloat16))
-
-    method.process_weights_after_loading(layer)
-
-    assert layer.output_channel_scale is None
-
-
-def test_compatibility_path_applies_qkv_scale_and_rank_correction(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    base_weight = torch.tensor(
-        [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]],
-        dtype=torch.bfloat16,
-    )
-    kernel = _FakeNvfp4Kernel(base_weight)
-    monkeypatch.setattr(svdquant, "_assert_supported", lambda: None)
-    monkeypatch.setattr(svdquant, "_nvfp4_kernel", lambda: kernel)
-    method = svdquant.DiffusionSVDQuantLinearMethod(svdquant.DiffusionSVDQuantConfig())
-
-    layer = torch.nn.Module()
-    layer.smooth_factor = torch.tensor([2.0, 4.0], dtype=torch.bfloat16)
-    layer.proj_down = torch.tensor([[1.0], [2.0]], dtype=torch.bfloat16)
-    layer.proj_up = torch.tensor([[1.0], [2.0], [3.0]], dtype=torch.bfloat16)
-    layer.output_channel_scale = torch.tensor([1.0, 2.0, 4.0], dtype=torch.bfloat16)
-    layer.output_size_per_partition = 3
-    x = torch.tensor([[2.0, 4.0], [4.0, 8.0]], dtype=torch.bfloat16)
-    bias = torch.tensor([1.0, 2.0, 3.0], dtype=torch.bfloat16)
-
-    actual = method.apply(layer, x, bias)
-
-    smoothed = x / layer.smooth_factor
-    expected = torch.mm(smoothed, base_weight)
-    expected = expected * layer.output_channel_scale
-    expected = expected + torch.mm(torch.mm(x, layer.proj_down), layer.proj_up.T)
-    expected = expected + bias
-    torch.testing.assert_close(actual, expected)
-    torch.testing.assert_close(kernel.last_input, smoothed)
-
-
-def test_compatibility_path_rejects_fp16_activations(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setattr(svdquant, "_assert_supported", lambda: None)
-    method = svdquant.DiffusionSVDQuantLinearMethod(svdquant.DiffusionSVDQuantConfig())
-    layer = torch.nn.Module()
-    with pytest.raises(ValueError, match="requires BF16 activations"):
-        method.apply(
-            layer,
-            torch.zeros(1, 16, dtype=torch.float16),
-        )
@@ -1,130 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-import pytest
-import torch
-from vllm.model_executor.layers.linear import (
-    ColumnParallelLinear,
-    QKVParallelLinear,
-    RowParallelLinear,
-)
-
-from vllm_omni.quantization import svdquant_config as svdquant
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
-
-
-def _linear_without_init(linear_type: type[torch.nn.Module], tp_rank: int):
-    layer = object.__new__(linear_type)
-    torch.nn.Module.__init__(layer)
-    layer.tp_rank = tp_rank
-    return layer
-
-
-def _values(shape: tuple[int, ...], dtype: torch.dtype) -> torch.Tensor:
-    values = torch.arange(torch.Size(shape).numel(), dtype=torch.int64).remainder(127)
-    return values.reshape(shape).to(dtype)
-
-
-def _method(monkeypatch: pytest.MonkeyPatch):
-    monkeypatch.setattr(svdquant, "_assert_supported", lambda: None)
-    return svdquant.DiffusionSVDQuantLinearMethod(svdquant.DiffusionSVDQuantConfig(rank=8))
-
-
-def test_column_parallel_loader_shards_svdquant_outputs(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    layer = _linear_without_init(ColumnParallelLinear, tp_rank=1)
-    method = _method(monkeypatch)
-    method.create_weights(
-        layer,
-        input_size_per_partition=128,
-        output_partition_sizes=[32],
-        input_size=128,
-        output_size=64,
-        params_dtype=torch.bfloat16,
-        weight_loader=layer.weight_loader,
-    )
-
-    loaded_tensors = {
-        "qweight": _values((64, 64), torch.int8),
-        "wscales": _values((8, 64), torch.float8_e4m3fn),
-        "proj_up": _values((64, 8), torch.bfloat16),
-        "wcscales": _values((64,), torch.bfloat16),
-    }
-    for name, loaded in loaded_tensors.items():
-        parameter = getattr(layer, name)
-        parameter.weight_loader(parameter, loaded)
-        expected = loaded.narrow(parameter.output_dim, 32, 32)
-        torch.testing.assert_close(parameter, expected)
-
-
-def test_row_parallel_loader_shards_svdquant_inputs(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    layer = _linear_without_init(RowParallelLinear, tp_rank=1)
-    method = _method(monkeypatch)
-    method.create_weights(
-        layer,
-        input_size_per_partition=64,
-        output_partition_sizes=[64],
-        input_size=128,
-        output_size=64,
-        params_dtype=torch.bfloat16,
-        weight_loader=layer.weight_loader,
-    )
-
-    loaded_tensors = {
-        "qweight": _values((64, 64), torch.int8),
-        "wscales": _values((8, 64), torch.float8_e4m3fn),
-        "proj_down": _values((128, 8), torch.bfloat16),
-        "smooth_factor": _values((128,), torch.bfloat16),
-    }
-    for name, loaded in loaded_tensors.items():
-        parameter = getattr(layer, name)
-        parameter.weight_loader(parameter, loaded)
-        shard_size = parameter.shape[parameter.input_dim]
-        expected = loaded.narrow(parameter.input_dim, shard_size, shard_size)
-        torch.testing.assert_close(parameter, expected)
-
-
-def test_qkv_parallel_loader_shards_fused_svdquant_outputs(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    layer = _linear_without_init(QKVParallelLinear, tp_rank=1)
-    layer.total_num_heads = 4
-    layer.total_num_kv_heads = 2
-    layer.num_heads = 2
-    layer.num_kv_heads = 1
-    layer.num_kv_head_replicas = 1
-    layer.head_size = 8
-    layer.v_head_size = 8
-    method = _method(monkeypatch)
-    method.create_weights(
-        layer,
-        input_size_per_partition=128,
-        output_partition_sizes=[16, 8, 8],
-        input_size=128,
-        output_size=64,
-        params_dtype=torch.bfloat16,
-        weight_loader=layer.weight_loader,
-    )
-
-    loaded_tensors = {
-        "qweight": _values((64, 64), torch.int8),
-        "wscales": _values((8, 64), torch.float8_e4m3fn),
-        "proj_up": _values((64, 8), torch.bfloat16),
-        "wcscales": _values((64,), torch.bfloat16),
-    }
-    expected_global_outputs = [slice(16, 32), slice(40, 48), slice(56, 64)]
-    for name, loaded in loaded_tensors.items():
-        parameter = getattr(layer, name)
-        parameter.weight_loader(parameter, loaded)
-        expected = torch.cat(
-            [
-                loaded.narrow(parameter.output_dim, part.start, part.stop - part.start)
-                for part in expected_global_outputs
-            ],
-            dim=parameter.output_dim,
-        )
-        torch.testing.assert_close(parameter, expected)
@@ -1,90 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-"""Wan AutoRound-format MXFP4 configuration and layer-mapping tests."""
-
-from unittest.mock import patch
-
-import pytest
-from torch import nn
-from vllm.model_executor.layers.linear import LinearBase
-from vllm.model_executor.model_loader.utils import configure_quant_config
-
-from vllm_omni.diffusion.models.wan2_2.wan2_2_transformer import (
-    WanTransformer3DModel,
-)
-from vllm_omni.quantization import build_quant_config
-from vllm_omni.quantization.inc_config import OmniINCConfig
-
-pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
-
-
-def _autoround_mxfp4_config() -> dict:
-    return {
-        "bits": 4,
-        "act_bits": 4,
-        "data_type": "mx_fp",
-        "act_data_type": "mx_fp",
-        "group_size": 32,
-        "act_group_size": 32,
-        "sym": True,
-        "act_sym": True,
-        "act_dynamic": True,
-        "enable_quanted_input": False,
-        "block_name_to_quantize": "blocks",
-        "quant_method": "auto-round",
-        "packing_format": "auto_round:llm_compressor",
-        "autoround_version": "0.14.2",
-    }
-
-
-def test_build_wan_autoround_mxfp4_config():
-    config = build_quant_config(_autoround_mxfp4_config())
-
-    assert isinstance(config, OmniINCConfig)
-    assert config.get_name() == "inc"
-    assert config.weight_bits == 4
-    assert config.data_type == "mx_fp"
-    assert config.group_size == 32
-    assert config.packing_format == "auto_round:llm_compressor"
-    assert config.block_name_to_quantize == ["blocks"]
-
-
-def test_wan_autoround_config_uses_runtime_layer_names():
-    config = build_quant_config(_autoround_mxfp4_config())
-    configure_quant_config(config, WanTransformer3DModel)
-
-    assert config.packed_modules_mapping is WanTransformer3DModel.packed_modules_mapping
-    assert config.block_name_to_quantize == ["blocks"]
-
-    layer = object.__new__(LinearBase)
-    nn.Module.__init__(layer)
-    for prefix in (
-        "blocks.0.ffn.net_0.proj",
-        "blocks.0.ffn.net_2",
-        "blocks.0.attn1.to_out",
-    ):
-        layer_config = config.config_parser.resolve(layer, prefix)
-        assert layer_config.quantized
-        assert layer_config.is_mxfp4
-
-
-def test_wan_autoround_scope_dispatches_only_blocks_to_mxfp4():
-    config = build_quant_config(_autoround_mxfp4_config())
-    configure_quant_config(config, WanTransformer3DModel)
-
-    layer = object.__new__(LinearBase)
-    nn.Module.__init__(layer)
-    layer_config = config.config_parser.resolve(layer, "blocks.0.ffn.net_0.proj")
-    outside_config = config.config_parser.resolve(layer, "condition_embedder.time_proj")
-
-    assert layer_config.quantized
-    assert layer_config.is_mxfp4
-    assert not outside_config.quantized
-
-    fake_method = object()
-    with patch(
-        "vllm.model_executor.layers.quantization.inc.schemes.inc_mxfp4_scheme.INCMxfp4Scheme.get_linear_method",
-        return_value=fake_method,
-    ):
-        method = config.get_quant_method(layer, "blocks.0.ffn.net_0.proj")
-    assert method is fake_method
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 """Source-level regression tests for diffusion output/engine helpers.

 These tests verify naming conventions and patterns by inspecting source code
@@ -37,50 +37,10 @@ _FORMATTER_PATH = os.path.normpath(
        "output_formatter.py",
    )
 )
-_METRICS_PATH = os.path.normpath(
-    os.path.join(
-        os.path.dirname(__file__),
-        os.pardir,
-        os.pardir,
-        "vllm_omni",
-        "metrics",
-        "utils.py",
-    )
-)
-_INLINE_CLIENT_PATH = os.path.normpath(
-    os.path.join(
-        os.path.dirname(__file__),
-        os.pardir,
-        os.pardir,
-        "vllm_omni",
-        "diffusion",
-        "inline_stage_diffusion_client.py",
-    )
-)
-_STAGE_PROC_PATH = os.path.normpath(
-    os.path.join(
-        os.path.dirname(__file__),
-        os.pardir,
-        os.pardir,
-        "vllm_omni",
-        "diffusion",
-        "stage_diffusion_proc.py",
-    )
-)
-_ORCHESTRATOR_PATH = os.path.normpath(
-    os.path.join(
-        os.path.dirname(__file__),
-        os.pardir,
-        os.pardir,
-        "vllm_omni",
-        "engine",
-        "orchestrator.py",
-    )
-)


 def _read_source(path: str) -> str:
-    with open(path, encoding="utf-8") as f:
+    with open(path) as f:
        return f.read()


@@ -140,116 +100,9 @@ class TestMetricKeys:
                raise AssertionError("diffusion_engine_total_time_ms should be attached in step_streaming()")

        assert '"diffusion_engine_exec_time_ms": exec_total_time * 1000' in step_streaming_source
-        # step_total_ms is no longer emitted as a metric (no family consumes
-        # it); it lives only in the debug log breakdown below.
-        assert '"diffusion_engine_total_time_ms"' not in step_streaming_source
+        assert '"diffusion_engine_total_time_ms": step_total_ms' in step_streaming_source
        assert '"postprocess_time_ms": postprocess_time * 1000' in step_streaming_source

-    def test_step_streaming_piggybacks_scheduler_waiting_snapshot(self) -> None:
-        source = _read_source(_ENGINE_PATH)
-        step_streaming_source = _get_function_source(source, "DiffusionEngine", "step_streaming")
-        assert "diffusion_scheduler_waiting_metrics(" in step_streaming_source
-        assert "_scheduler_num_waiting_reqs" in step_streaming_source
-
-    def test_step_streaming_preserves_snapshot_on_postprocess_error(self) -> None:
-        source = _read_source(_ENGINE_PATH)
-        step_streaming_source = _get_function_source(source, "DiffusionEngine", "step_streaming")
-        assert "scheduler_metrics = diffusion_scheduler_waiting_metrics(" in step_streaming_source
-        assert 'setattr(exc, "diffusion_metrics", scheduler_metrics)' in step_streaming_source
-        assert step_streaming_source.index("scheduler_metrics =") < step_streaming_source.index(
-            "self.postprocess_output("
-        )
-
-    def test_abort_keeps_output_consumers_alive_for_terminal_snapshot(self) -> None:
-        inline_source = _read_source(_INLINE_CLIENT_PATH)
-        abort_source = _get_function_source(inline_source, "InlineStageDiffusionClient", "abort_requests_async")
-        assert ".cancel(" not in abort_source
-
-        proc_source = _read_source(_STAGE_PROC_PATH)
-        run_loop_source = _get_function_source(proc_source, "StageDiffusionProc", "run_loop")
-        abort_branch = run_loop_source[run_loop_source.index('elif msg_type == "abort":') :]
-        abort_branch = abort_branch[: abort_branch.index('elif msg_type == "collective_rpc":')]
-        assert ".cancel(" not in abort_branch
-
-    def test_orchestrator_consumes_metrics_only_output_without_routing(self) -> None:
-        """A metrics-only sentinel contributes its queue depth and is not routed.
-
-        Absorption lives in ``_absorb_diffusion_metrics`` rather than inline in a
-        loop, so both orchestration loops share one implementation. The ordering
-        is asserted where it now lives: the snapshot inside the helper, and the
-        absorb-before-route guard inside every loop that polls diffusion output.
-        """
-        source = _read_source(_ORCHESTRATOR_PATH)
-
-        # Snapshot before the verdict, so a sentinel still reports its waiting
-        # depth on the way out instead of being dropped unaccounted.
-        absorb_source = _get_function_source(source, "Orchestrator", "_absorb_diffusion_metrics")
-        snapshot_pos = absorb_source.index("_update_stage_replica_waiting(")
-        sentinel_pos = absorb_source.index("diffusion_output.request_id == DIFFUSION_METRICS_ONLY_REQUEST_ID")
-        assert snapshot_pos < sentinel_pos
-
-        # Absorb before routing, or a sentinel reaches the downstream consumer
-        # as if it were a real request output.
-        for loop_name in ("_orchestration_loop", "_orchestration_loop_event_driven"):
-            loop_source = _get_function_source(source, "Orchestrator", loop_name)
-            absorb_pos = loop_source.index("self._absorb_diffusion_metrics(")
-            route_pos = loop_source.index("record_output_timestamps(")
-            assert absorb_pos < route_pos, loop_name
-
-
-class TestVaeDecodeEmit:
-    """VAE decode timing is sourced from ``DiffusionOutput.stage_durations``
-    (populated by the diffusion pipeline profiler) and emitted as
-    ``vae_decode_time_ms`` so the ``_MS_TO_S`` accumulator picks it up.
-    """
-
-    def test_extract_vae_decode_ms_helper_exists(self) -> None:
-        source = _read_source(_METRICS_PATH)
-        helper_src = _get_function_source(source, None, "extract_diffusion_vae_decode_ms")
-        assert ".vae.decode" in helper_src, "helper must key on the '.vae.decode' suffix"
-
-    def test_step_streaming_emits_vae_decode_time_ms(self) -> None:
-        source = _read_source(_ENGINE_PATH)
-        step_streaming_source = _get_function_source(source, "DiffusionEngine", "step_streaming")
-        assert "extract_diffusion_vae_decode_ms(" in step_streaming_source, (
-            "step_streaming must call extract_diffusion_vae_decode_ms to source VAE decode timing"
-        )
-        assert '"vae_decode_time_ms"' in step_streaming_source, (
-            "step_streaming must emit vae_decode_time_ms key for the _MS_TO_S accumulator"
-        )
-
-
-class TestDiffuseForwardEmit:
-    """Forward-only timing → forward_time_ms, mirroring TestVaeDecodeEmit."""
-
-    def test_extract_diffuse_ms_helper_exists(self) -> None:
-        source = _read_source(_METRICS_PATH)
-        helper_src = _get_function_source(source, None, "extract_diffusion_denoise_ms")
-        assert ".diffuse" in helper_src, "helper must key on the '.diffuse' suffix"
-
-    def test_step_streaming_emits_forward_time_ms(self) -> None:
-        source = _read_source(_ENGINE_PATH)
-        step_streaming_source = _get_function_source(source, "DiffusionEngine", "step_streaming")
-        assert "extract_diffusion_denoise_ms(" in step_streaming_source, (
-            "step_streaming must call extract_diffusion_denoise_ms to source forward-only timing"
-        )
-        assert '"forward_time_ms"' in step_streaming_source, (
-            "step_streaming must emit forward_time_ms key for the _MS_TO_S accumulator"
-        )
-
-
-class TestKvRecvEmit:
-    """KV-recv timing → kv_recv_time_ms, sourced from DiffusionOutput.kv_recv_ms
-    (set by the runner's _prepare_request_for_forward, not the profiler)."""
-
-    def test_step_streaming_emits_kv_recv_time_ms(self) -> None:
-        source = _read_source(_ENGINE_PATH)
-        step_streaming_source = _get_function_source(source, "DiffusionEngine", "step_streaming")
-        assert "kv_recv_ms" in step_streaming_source, "step_streaming must read output.kv_recv_ms"
-        assert '"kv_recv_time_ms"' in step_streaming_source, (
-            "step_streaming must emit kv_recv_time_ms key for the _MS_TO_S accumulator"
-        )
-

 class TestDummyRunAllocation:
    """Verify _dummy_run generates exact-sized audio arrays."""
@@ -181,7 +181,7 @@ def test_diffusion_output_dict_tensors_round_trip_through_shm() -> None:


 def test_diffusion_output_tuple_tensors_round_trip_through_shm() -> None:
-    # LTX2 returns (video, audio) tuples as DiffusionOutput.output.
+    # LTX2 / DreamID return (video, audio) tuples as DiffusionOutput.output.
    video = torch.arange(300_000, dtype=torch.float32)
    audio = torch.arange(300_000, dtype=torch.float32) * 3
    output = DiffusionOutput(output=(video, audio))