Fix LTX2 channels-last review scope

Signed-off-by: Hongsheng Liu <liuhongsheng4@huawei.com>

.buildkite/cuda/test-merge.yml

@@ -139,7 +139,12 @@ steps:
         timeout_in_minutes: 50
         commands:
           - pytest -s -v tests/e2e/offline_inference/test_minicpmo_4_5.py tests/e2e/online_serving/test_minicpmo_4_5.py -m 'advanced_model and cuda' --run-level 'advanced_model'
-        mirror_hardwares: h100_1
+        # h100_2, not h100_1: advanced_model asserts transcribe every audio
+        # response with Whisper, and tests/helpers/media.py only uses an
+        # accelerator for Whisper when a spare GPU exists. On a single card it
+        # grades on CPU: ~8-10 min per clip vs ~30 s, which alone overruns the
+        # 50-minute job timeout (build 2956).
+        mirror_hardwares: h100_2
 
       - label: "Omni · MiniCPM-o 4.5 Duplex Test"
         source_file_dependencies:

.buildkite/cuda/test-ready.yml

@@ -128,6 +128,21 @@ steps:
               image: public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT
               always-pull: true
               propagate-environment: true
+              # vLLM 0.27 added a pre-flight capacity check in
+              # distributed/device_communicators/shm_broadcast.py. Without this
+              # the container gets Docker's 64 MiB default and every test in
+              # this step dies at engine start with
+              #   RuntimeError: Insufficient space in /dev/shm:
+              #                 240 MiB required, 64 MiB available
+              # (9 failed in 8.7s on build #2949). vLLM 0.26 had no such check
+              # and allocated regardless, so this step passed on main while
+              # being under-provisioned the whole time — 0.27 turned a silent
+              # risk into an explicit error.
+              #
+              # This is the only inline docker plugin block in .buildkite/cuda/;
+              # every other step inherits common/ci_mirror_hardwares.yml, which
+              # already sets 8gb. Matching that rather than inventing a value.
+              shm-size: "8gb"
               environment:
                 - "HF_HOME=/fsx/hf_cache"
               volumes:
@@ -212,6 +227,18 @@ steps:
             "
         mirror_hardwares: h100_1
 
+      - label: "Omni · MiniCPM-o 4.5 Perf Test"
+        timeout_in_minutes: 60
+        source_file_dependencies:
+          - tests/dfx/perf/tests/test_minicpmo_4_5_ready.json
+          - vllm_omni/deploy/minicpmo_4_5.yaml
+          - vllm_omni/model_executor/models/minicpmo_4_5/
+          - vllm_omni/model_executor/stage_input_processors/minicpmo_4_5_omni.py
+        commands:
+          - export BENCHMARK_DIR=tests/dfx/perf/results
+          - pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_minicpmo_4_5_ready.json -m 'core_model and cuda'
+        mirror_hardwares: h100_1
+
       - label: "TTS · VoxCPM2 Test"
         source_file_dependencies:
           - tests/e2e/online_serving/test_voxcpm2_tts.py

.buildkite/intel/pipeline-intel.yml

@@ -10,7 +10,7 @@ steps:
           DOCKER_BUILDKIT: "1"
           # Buildkite will automatically replace this with the actual commit hash
           VLLM_IMAGE_TAG: "${BUILDKITE_COMMIT}"
-          VLLM_VERSION: "v0.26.0"
+          VLLM_VERSION: "v0.27.0"
         priority: 100
         timeout_in_minutes: 60
         soft_fail: false

.buildkite/intel/scripts/run-xpu-test.sh

@@ -34,8 +34,23 @@ docker_build() {
     docker build "${out[@]}" "$@" -f docker/Dockerfile.xpu .
 }
 
+build_vllm_base() (
+    local vllm_source_dir
+    vllm_source_dir=$(mktemp -d)
+    trap 'rm -rf "${vllm_source_dir}"' EXIT
+
+    git clone --depth 1 --branch "${VLLM_VERSION}" \
+        https://github.com/vllm-project/vllm "${vllm_source_dir}"
+
+    local out=("${export_args[@]/'{{IMAGE}}'/${base_image_name}}")
+    docker build "${out[@]}" \
+        --target vllm-openai \
+        -f "${vllm_source_dir}/docker/Dockerfile.xpu" \
+        "${vllm_source_dir}"
+)
+
 if [ -z "$(docker images -q "${base_image_name}")" ]; then
-    docker_build "${base_image_name}" --target vllm-base --build-arg "VLLM_VERSION=${VLLM_VERSION}"
+    build_vllm_base
 fi
 
 # Try building the docker image

.buildkite/npu/test-npu-ready.yml

@@ -17,6 +17,15 @@ steps:
           VLLM_ALLOW_LONG_MAX_MODEL_LEN: "1"
         commands:
           - pytest -s -v tests/e2e/online_serving/test_minicpmo_4_5_duplex.py -m 'core_model and npu and A3 and omni' --run-level 'core_model'
+      - label: "Omni · MiniCPM-o 4.5 Perf Test"
+        timeout_in_minutes: 60
+        mirror_hardwares: a3_npu_2
+        env:
+          VLLM_WORKER_MULTIPROC_METHOD: spawn
+          VLLM_ALLOW_LONG_MAX_MODEL_LEN: "1"
+        commands:
+          - export BENCHMARK_DIR=tests/dfx/perf/results
+          - pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_minicpmo_4_5_ready.json -m 'core_model and npu and A3 and omni'
 
   - group: ":card_index_dividers: TTS Model Test"
     key: ready-tts-group

.buildkite/release/release-pipeline.yml

@@ -40,9 +40,11 @@ steps:
     commands:
       - "bash .buildkite/release/scripts/publish-release-wheels-pypi.sh"
 
+  # Auto-skip when NIGHTLY=1 (scheduled); otherwise require manual unblock.
   - block: "Unblock to build release Docker images"
     depends_on: ~
     key: block-build-release-images
+    if: build.env("NIGHTLY") != "1"
 
   - group: "Build release Docker images"
     key: "build-release-images"
@@ -63,7 +65,7 @@ steps:
               --progress plain \
               -f docker/Dockerfile.cuda .
           - "docker push public.ecr.aws/q9t5s3a7/vllm-omni-release-repo:$BUILDKITE_COMMIT-$(uname -m)"
-          # re-tag to default image tag and push, just in case arm64 build fails
+          # Fallback default tag (no arch suffix) if arm64 build fails.
           - "docker tag public.ecr.aws/q9t5s3a7/vllm-omni-release-repo:$BUILDKITE_COMMIT-$(uname -m) public.ecr.aws/q9t5s3a7/vllm-omni-release-repo:$BUILDKITE_COMMIT"
           - "docker push public.ecr.aws/q9t5s3a7/vllm-omni-release-repo:$BUILDKITE_COMMIT"
         env:
@@ -86,6 +88,26 @@ steps:
         env:
           DOCKER_BUILDKIT: "1"
 
+  # NIGHTLY=1 only: promote ECR images to DockerHub nightly tags, then prune.
+  - label: "Publish nightly multi-arch image to DockerHub"
+    depends_on:
+      - build-release-image-x86
+      - build-release-image-arm64
+    if: build.env("NIGHTLY") == "1"
+    key: publish-nightly-images-dockerhub
+    agents:
+      queue: small_cpu_queue_release
+    commands:
+      - "bash .buildkite/release/scripts/publish-release-images.sh nightly"
+      - "bash .buildkite/release/scripts/cleanup-nightly-builds.sh"
+    plugins:
+      - docker-login#v3.0.0:
+          username: vllmbot
+          password-env: DOCKERHUB_TOKEN
+    env:
+      DOCKER_BUILDKIT: "1"
+      DOCKERHUB_USERNAME: "vllmbot"
+
   - block: "Publish release images to DockerHub"
     key: block-publish-release-images
     depends_on:

.buildkite/release/scripts/cleanup-nightly-builds.sh

@@ -0,0 +1,147 @@
+#!/bin/bash
+# SPDX-License-Identifier: Apache-2.0
+#
+# Clean up old nightly builds from DockerHub (vllm/vllm-omni), keeping the
+# newest 14 tags with the nightly- prefix.
+
+set -ex
+
+TAG_PREFIX="nightly-"
+REPO="vllm/vllm-omni"
+REPO_API_URL="https://hub.docker.com/v2/repositories/${REPO}/tags"
+
+echo "Cleaning up tags with prefix: $TAG_PREFIX in repository: $REPO"
+
+if [ -z "$DOCKERHUB_TOKEN" ]; then
+  echo "Error: DOCKERHUB_TOKEN environment variable is not set"
+  exit 1
+fi
+
+if [ -z "$DOCKERHUB_USERNAME" ]; then
+  echo "Error: DOCKERHUB_USERNAME environment variable is not set"
+  exit 1
+fi
+
+echo "Getting DockerHub bearer token..."
+set +x
+BEARER_TOKEN=$(curl -s -X POST \
+  -H "Content-Type: application/json" \
+  -d "{\"username\": \"$DOCKERHUB_USERNAME\", \"password\": \"$DOCKERHUB_TOKEN\"}" \
+  "https://hub.docker.com/v2/users/login" | jq -r '.token')
+set -x
+
+if [ -z "$BEARER_TOKEN" ] || [ "$BEARER_TOKEN" = "null" ]; then
+  echo "Error: Failed to get DockerHub bearer token"
+  exit 1
+fi
+
+get_all_tags() {
+  local page=1
+  local all_tags=""
+  # Hub `name` is a partial match (not a strict prefix). Use it to narrow the
+  # list, then enforce startswith() client-side. Exhaust API pages; do not
+  # stop merely because a page has no matching tags after filtering.
+  local name_query
+  name_query=$(printf '%s' "$TAG_PREFIX" | jq -sRr @uri)
+
+  while true; do
+    set +x
+    local response
+    response=$(curl -s -H "Authorization: Bearer $BEARER_TOKEN" \
+      "$REPO_API_URL?page=$page&page_size=100&name=${name_query}")
+    set -x
+
+    local page_count
+    page_count=$(echo "$response" | jq -r '.results | length')
+    if [ -z "$page_count" ] || [ "$page_count" = "0" ] || [ "$page_count" = "null" ]; then
+      break
+    fi
+
+    local tags
+    tags=$(echo "$response" | jq -r --arg prefix "$TAG_PREFIX" \
+      '.results[] | select(.name | startswith($prefix)) | "\(.last_updated)|\(.name)"')
+
+    if [ -n "$tags" ]; then
+      all_tags="$all_tags$tags"$'\n'
+    fi
+    page=$((page + 1))
+  done
+
+  echo "$all_tags" | sort -r | cut -d'|' -f2
+}
+
+delete_tag() {
+  local tag_name="$1"
+  echo "Deleting tag: $tag_name"
+
+  local delete_url="https://hub.docker.com/v2/repositories/${REPO}/tags/$tag_name"
+  set +x
+  local response http_code body
+  response=$(curl -s -w "\n%{http_code}" -X DELETE \
+    -H "Authorization: Bearer $BEARER_TOKEN" "$delete_url")
+  set -x
+  http_code=$(printf '%s\n' "$response" | tail -n1)
+  body=$(printf '%s\n' "$response" | sed '$d')
+
+  if [ "$http_code" -ge 200 ] && [ "$http_code" -lt 300 ]; then
+    echo "Successfully deleted tag: $tag_name (HTTP ${http_code})"
+    return 0
+  fi
+
+  local detail=""
+  if echo "$body" | jq -e '.detail' > /dev/null 2>&1; then
+    detail=$(echo "$body" | jq -r '.detail')
+  elif [ -n "$body" ]; then
+    detail="$body"
+  else
+    detail="(empty response body)"
+  fi
+  echo "Error: Failed to delete tag $tag_name (HTTP ${http_code}): ${detail}"
+  return 1
+}
+
+echo "Fetching all tags from DockerHub..."
+all_tags=$(get_all_tags)
+
+if [ -z "$all_tags" ]; then
+  echo "No tags found to clean up"
+  exit 0
+fi
+
+total_tags=$(echo "$all_tags" | wc -l)
+echo "Found $total_tags tags"
+
+tags_to_keep=14
+tags_to_delete=$((total_tags - tags_to_keep))
+
+if [ $tags_to_delete -le 0 ]; then
+  echo "No tags need to be deleted (only $total_tags tags found, keeping $tags_to_keep)"
+  exit 0
+fi
+
+echo "Will delete $tags_to_delete old tags, keeping the newest $tags_to_keep"
+
+tags_to_delete_list=$(echo "$all_tags" | tail -n +$((tags_to_keep + 1)))
+
+if [ -z "$tags_to_delete_list" ]; then
+  echo "No tags to delete"
+  exit 0
+fi
+
+echo "Deleting old tags..."
+delete_failures=0
+while IFS= read -r tag; do
+  if [ -n "$tag" ]; then
+    if ! delete_tag "$tag"; then
+      delete_failures=$((delete_failures + 1))
+    fi
+    sleep 1
+  fi
+done <<< "$tags_to_delete_list"
+
+if [ "$delete_failures" -gt 0 ]; then
+  echo "Cleanup finished with ${delete_failures} deletion failure(s)"
+  exit 1
+fi
+
+echo "Cleanup completed successfully"

.buildkite/release/scripts/publish-release-images.sh

@@ -1,50 +1,87 @@
 #!/bin/bash
 # SPDX-License-Identifier: Apache-2.0
 #
-# Publish release Docker images from ECR to DockerHub.
-# Pulls per-arch images, tags with `latest` and versioned tags, pushes them,
-# then creates and pushes a multi-arch manifest.
+# Publish Docker images from ECR staging to DockerHub.
+#
+# Usage:
+#   publish-release-images.sh            # release mode (default)
+#   publish-release-images.sh release
+#   publish-release-images.sh nightly
+#
+# Release tags: latest, v<version>
+# Nightly tags: nightly, nightly-<commit>
 
 set -euo pipefail
 
-RELEASE_VERSION=$(buildkite-agent meta-data get release-version --default "" | sed 's/^v//')
-if [ -z "${RELEASE_VERSION}" ]; then
-  echo "ERROR: release-version metadata not set"
-  exit 1
-fi
+MODE="${1:-release}"
 
-COMMIT="$BUILDKITE_COMMIT"
 DOCKERHUB_REPO="vllm/vllm-omni"
 ECR_REPO="public.ecr.aws/q9t5s3a7/vllm-omni-release-repo"
+COMMIT="$BUILDKITE_COMMIT"
+PRIMARY_TAGS=()
+EXTRA_MANIFEST_TAGS=()
+
+case "${MODE}" in
+  release)
+    RELEASE_VERSION=$(buildkite-agent meta-data get release-version --default "" | sed 's/^v//')
+    if [ -z "${RELEASE_VERSION}" ]; then
+      echo "ERROR: release-version metadata not set"
+      exit 1
+    fi
+    PRIMARY_TAGS=("latest" "v${RELEASE_VERSION}")
+    ;;
+  nightly)
+    # Commit-pinned manifest reuses nightly-{x86_64,aarch64} arch images.
+    PRIMARY_TAGS=("nightly")
+    EXTRA_MANIFEST_TAGS=("nightly-${COMMIT}")
+    ;;
+  *)
+    echo "Usage: $0 {release|nightly}"
+    exit 2
+    ;;
+esac
 
 echo "========================================"
-echo "Publishing release images v${RELEASE_VERSION}"
+echo "Publishing ${MODE} images to ${DOCKERHUB_REPO}"
 echo "  Commit: ${COMMIT}"
+echo "  Primary tags: ${PRIMARY_TAGS[*]}"
+if [ ${#EXTRA_MANIFEST_TAGS[@]} -gt 0 ]; then
+  echo "  Extra manifests: ${EXTRA_MANIFEST_TAGS[*]}"
+fi
 echo "========================================"
 
-# Login to ECR to pull staging images
 aws ecr-public get-login-password --region us-east-1 | \
   docker login --username AWS --password-stdin public.ecr.aws/q9t5s3a7
 
-docker pull "${ECR_REPO}:${COMMIT}-x86_64"
-docker pull "${ECR_REPO}:${COMMIT}-aarch64"
+SRC_X86="${ECR_REPO}:${COMMIT}-x86_64"
+SRC_ARM="${ECR_REPO}:${COMMIT}-aarch64"
 
-docker tag "${ECR_REPO}:${COMMIT}-x86_64" "${DOCKERHUB_REPO}:latest-x86_64"
-docker tag "${ECR_REPO}:${COMMIT}-x86_64" "${DOCKERHUB_REPO}:v${RELEASE_VERSION}-x86_64"
-docker push "${DOCKERHUB_REPO}:latest-x86_64"
-docker push "${DOCKERHUB_REPO}:v${RELEASE_VERSION}-x86_64"
+docker pull "${SRC_X86}"
+docker pull "${SRC_ARM}"
 
-docker tag "${ECR_REPO}:${COMMIT}-aarch64" "${DOCKERHUB_REPO}:latest-aarch64"
-docker tag "${ECR_REPO}:${COMMIT}-aarch64" "${DOCKERHUB_REPO}:v${RELEASE_VERSION}-aarch64"
-docker push "${DOCKERHUB_REPO}:latest-aarch64"
-docker push "${DOCKERHUB_REPO}:v${RELEASE_VERSION}-aarch64"
+publish_manifest() {
+  local tag="$1"
+  local arch_tag_base="$2"
+  docker manifest rm "${DOCKERHUB_REPO}:${tag}" || true
+  docker manifest create \
+    "${DOCKERHUB_REPO}:${tag}" \
+    "${DOCKERHUB_REPO}:${arch_tag_base}-x86_64" \
+    "${DOCKERHUB_REPO}:${arch_tag_base}-aarch64"
+  docker manifest push "${DOCKERHUB_REPO}:${tag}"
+}
 
-docker manifest rm "${DOCKERHUB_REPO}:latest" || true
-docker manifest rm "${DOCKERHUB_REPO}:v${RELEASE_VERSION}" || true
-docker manifest create "${DOCKERHUB_REPO}:latest" "${DOCKERHUB_REPO}:latest-x86_64" "${DOCKERHUB_REPO}:latest-aarch64"
-docker manifest create "${DOCKERHUB_REPO}:v${RELEASE_VERSION}" "${DOCKERHUB_REPO}:v${RELEASE_VERSION}-x86_64" "${DOCKERHUB_REPO}:v${RELEASE_VERSION}-aarch64"
-docker manifest push "${DOCKERHUB_REPO}:latest"
-docker manifest push "${DOCKERHUB_REPO}:v${RELEASE_VERSION}"
+for tag in "${PRIMARY_TAGS[@]}"; do
+  docker tag "${SRC_X86}" "${DOCKERHUB_REPO}:${tag}-x86_64"
+  docker tag "${SRC_ARM}" "${DOCKERHUB_REPO}:${tag}-aarch64"
+  docker push "${DOCKERHUB_REPO}:${tag}-x86_64"
+  docker push "${DOCKERHUB_REPO}:${tag}-aarch64"
+  publish_manifest "${tag}" "${tag}"
+done
+
+ARCH_BASE="${PRIMARY_TAGS[0]}"
+for tag in "${EXTRA_MANIFEST_TAGS[@]}"; do
+  publish_manifest "${tag}" "${ARCH_BASE}"
+done
 
 echo ""
-echo "Successfully published release images for v${RELEASE_VERSION}"
+echo "Successfully published ${MODE} images"

.claude/skills/precheck-pr/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: precheck-pr
-description: Self-check your branch before creating a PR — catch dead code, verify accuracy/perf claims, validate PR title format, and confirm merge readiness. Use when the user says "precheck", "self review", "pre-submit check", or "check my PR before I open it." Never posts to GitHub.
+description: Self-check your branch before creating a PR — catch dead code, prevent new model-specific Python examples, verify accuracy/perf claims, validate PR title format, and confirm merge readiness. Use when the user says "precheck", "self review", "pre-submit check", or "check my PR before I open it." Never posts to GitHub.
 ---
 
 # PR Pre-Check
@@ -65,6 +65,8 @@ Ask: "Quick mode or full mode?" Then walk the checklist for the detected PR type
 
 **Also run the Code-Quality sweep on every PR**, regardless of type or mode: the five diff-scoped checks in [references/code-quality.md](references/code-quality.md) — kwargs fragility, broad-except swallow, `Any`/wrong type hints, hot-path `.clone()`/`deepcopy`, and event-loop blocking — plus the advisory conventions (log level, structured logging, synchronization, cleanup, dependencies, naming) in [checklists.md](references/checklists.md). These count only lines the PR *adds* — the pre-existing backlog across the repo is out of scope.
 
+**Also run the Examples-Policy check on every PR** using [references/examples-policy.md](references/examples-policy.md). Inspect only Python paths introduced by the diff. Treat a new model-, checkpoint-, vendor-, or family-specific Python example as blocking; do not report pre-existing example debt.
+
 ### Step 5: Print Report
 
 ```
@@ -77,6 +79,7 @@ Pre-check report for <branch>
   ─────────────────  ──────
   PR title format    ✓
   Code quality       ⚠ 1 broad except, 2 Any hints
+  Examples policy    ✗ new model-specific Python example
   PR desc integrity  ✓
   Registry/config    ✓
   Dead code          ⚠ 2 warnings

.claude/skills/precheck-pr/references/checklists.md

@@ -47,6 +47,19 @@ Diff-scoped sweep for five fragility patterns that are pervasive in the existing
 
 Roll the ⚠/✗ counts into the report as a single **Code quality** dimension row.
 
+---
+
+## All PRs: Examples Policy (run on every PR, quick & full)
+
+Inspect Python files introduced under `examples/` using
+[examples-policy.md](examples-policy.md). This is a diff-scoped ratchet: existing
+model-specific examples may be edited or removed without triggering the check.
+
+- [ ] **No new model-specific Python examples:** the diff adds, copies, or renames no Python file whose path or behavior is specific to one model, checkpoint, vendor, or model family. ✗ for any violation. Route inference through a shared task/protocol entrypoint, model request behavior through `vllm_omni/model_extras`, and commands through task docs or `recipes/`.
+- [ ] **New generic example code is justified:** any new task-neutral Python file under `examples/` is an actual user-facing entrypoint rather than reusable production logic, a benchmark, an app, a setup tool, or a reproducer. ⚠ when the placement is questionable.
+
+Roll the result into the report as a separate **Examples policy** dimension.
+
 ### Conventions (eyeball — no grep)
 
 Judgment calls that don't grep cleanly — apply them while reading the diff, not as a mechanical check:

.claude/skills/precheck-pr/references/examples-policy.md

@@ -0,0 +1,68 @@
+# Examples Python Policy
+
+Prevent new model-specific Python examples without forcing cleanup of the
+existing backlog. Run this check on every PR in quick and full modes.
+
+## Scope
+
+Set the merge base as in the main workflow, then list Python paths introduced
+by the PR, including additions, copies, and renames:
+
+```bash
+BASE="$(git merge-base HEAD origin/main)"
+git diff --name-status --diff-filter=ACR --find-renames --find-copies \
+  "${BASE}"...HEAD -- 'examples/**/*.py'
+```
+
+Inspect destination paths for copies and renames. Existing model-specific files
+that are only modified or deleted are grandfathered and must not be reported.
+
+## Blocking classification
+
+Mark ✗ when a newly introduced Python file does any of the following:
+
+- Names or scopes a path to one model, checkpoint, vendor, or model family.
+- Hard-codes a model identifier, model-specific prompt, request shape, output
+  conversion, or launch configuration behind an otherwise generic filename.
+- Duplicates an existing task/protocol runner to demonstrate one model.
+- Adds a per-model helper below a generic task hub such as `text_to_speech/`.
+
+Do not infer safety from a generic filename alone. For example, a file named
+`text_to_audio.py` is still model-specific if it only implements one model's
+contract.
+
+## Acceptable additions
+
+A new Python example may pass when it is a genuinely model-neutral,
+user-facing task or protocol entrypoint. It must accept model selection through
+configuration and keep model-specific behavior out of the script.
+
+Use ⚠ when the file is model-neutral but reusable logic appears misplaced under
+`examples/`. Route code by purpose:
+
+| Code purpose | Preferred location |
+|---|---|
+| Model prompt, defaults, request/output adaptation | `vllm_omni/model_extras/` or production model modules |
+| Runnable model command and validation evidence | Task documentation or `recipes/` |
+| UI or interactive application | `apps/` |
+| Benchmark or evaluator | `benchmarks/` |
+| Regression reproducer | `tests/` |
+| Download, conversion, or setup utility | `tools/` |
+
+If a model cannot use an existing shared runner, report the missing generic
+capability. Do not solve the gap by adding a model-specific Python example.
+
+## Report format
+
+Add one row to the pre-check report:
+
+```text
+Examples policy    ✓ no new Python example paths
+Examples policy    ⚠ generic helper belongs in tools/
+Examples policy    ✗ examples/offline_inference/new_model/end2end.py is model-specific
+Examples policy    ✗ examples/offline_inference/x_to_y_model_name.py is model-specific
+```
+
+For a blocker, name the path, the model-specific behavior, and the appropriate
+shared runner or destination. Do not propose deleting unrelated existing
+examples as part of the PR.

.claude/skills/review-pr/SKILL.md

@@ -97,6 +97,7 @@ If docs and live code disagree, verify the code/tests and report the drift.
 | [test-quality-evaluation.md](references/checks/test-quality-evaluation.md) | Tests change, are absent for risky code, or may not exercise production behavior. |
 | [tests-docs-checklist.md](references/checks/tests-docs-checklist.md) | Coverage, CI markers, examples, user docs, or PR evidence need review. |
 | [verification.md](references/checks/verification.md) | Hardware, a server, or a runnable affected path is available for active verification. |
+| [examples-policy.md](../precheck-pr/references/examples-policy.md) | The PR adds, copies, or renames Python under `examples/`; apply the canonical policy shared with `precheck-pr`. |
 
 ### Delivery and reviewer coordination
 
@@ -152,6 +153,13 @@ contract they protect or use only the applicable evidence checks.
 Apply every category in [general-checks.md](references/process/general-checks.md) before
 lower-priority comments.
 
+If the diff census contains an added, copied, or renamed Python path under
+`examples/`, read and apply the canonical
+[examples policy](../precheck-pr/references/examples-policy.md). Treat a new
+model-specific Python example as blocking. Do not flag model-specific example
+debt that the PR only modifies or removes, and do not run the rest of the
+author-oriented `precheck-pr` workflow.
+
 For each changed value or behavior, trace:
 
 ```text

benchmarks/diffusion/quantization_quality.py

@@ -158,7 +158,6 @@ def _build_omni_kwargs(args, quantization=None):
 def _generate_image(omni, args, prompt, seed):
     """Generate a single image and return (PIL.Image, time_seconds, memory_gib)."""
     from vllm_omni.inputs.data import OmniDiffusionSamplingParams
-    from vllm_omni.outputs import OmniRequestOutput
     from vllm_omni.platforms import current_omni_platform
 
     generator = torch.Generator(device=current_omni_platform.device_type).manual_seed(seed)
@@ -176,7 +175,7 @@ def _generate_image(omni, args, prompt, seed):
     elapsed = time.perf_counter() - start
     peak_mem = torch.accelerator.max_memory_allocated() / (1024**3)
 
-    req_out = OmniRequestOutput.unwrap_result(outputs)
+    req_out = outputs[0] if isinstance(outputs, list) else outputs
     if not req_out.images:
         raise ValueError("Could not extract image output from result.")
     img = req_out.images[0]
@@ -206,15 +205,15 @@ def _generate_video(omni, args, prompt, seed):
     elapsed = time.perf_counter() - start
     peak_mem = torch.accelerator.max_memory_allocated() / (1024**3)
 
-    first = outputs[0]
-    if hasattr(first, "request_output") and isinstance(first.request_output, list):
-        inner = first.request_output[0]
-        if isinstance(inner, OmniRequestOutput) and hasattr(inner, "images"):
-            frames = inner.images[0] if inner.images else None
-        else:
-            frames = inner
-    elif hasattr(first, "images") and first.images:
-        frames = first.images[0]
+    if isinstance(outputs, list) and isinstance(outputs[0], OmniRequestOutput):
+        first = outputs[0]
+    elif isinstance(outputs, OmniRequestOutput):
+        first = outputs
+    else:
+        raise ValueError("Could not extract video frames from output.")
+
+    if hasattr(first, "images"):
+        frames = first.images[0] if first.images else None
     else:
         raise ValueError("Could not extract video frames from output.")
 

benchmarks/glm_image/vllm-omni/inference.py

@@ -300,7 +300,7 @@ def benchmark(args: argparse.Namespace) -> None:
         output_idx = 0
         for stage_outputs in omni.generate(all_prompts, sampling_params_list, py_generator=True):
             if stage_outputs.final_output_type == "image":
-                request_output = stage_outputs.request_output
+                request_output = stage_outputs
                 request_id = getattr(request_output, "request_id", "")
 
                 images = getattr(request_output, "images", [])

benchmarks/tts/README.md

@@ -139,6 +139,34 @@ python benchmarks/tts/bench_tts.py \
     --output-dir ./results
 ```
 
+#### Fixed IndexTTS 2.5 performance sweep
+
+IndexTTS 2.5 is registered in `model_configs.yaml` like the other TTS models.
+Use `--served-model-name` when the server was launched from a local native
+bundle instead of the registry key. The command below reproduces the acceptance
+workload: Seed-TTS Eval EN, `n=500`, concurrency `4/8/16/32`, five warmups, and
+dataset seed 0.
+
+```bash
+python benchmarks/tts/bench_tts.py \
+    --model IndexTeam/IndexTTS-2.5 \
+    --served-model-name /path/to/indextts-2.5 \
+    --task voice_clone --locale en \
+    --dataset-path /path/to/seedtts_testset \
+    --host 127.0.0.1 --port 8092 \
+    --concurrency 4 8 16 32 \
+    --num-prompts 500 --num-warmups 5 \
+    --output-dir ./results/indextts2_5 \
+    -- \
+    --tokenizer /path/to/indextts-2.5/qwen0.6bemo4-merge \
+    --seed 0 --metric-percentiles 50,95,99 --disable-tqdm --save-detailed
+```
+
+The wrapper benchmarks an already-running server. For reproducible quality
+comparisons, add `--request-seed 42`; production-performance runs should omit
+it. The trailing `--seed 0` controls Seed-TTS row selection rather than model
+sampling.
+
 ### 4. Plot a sweep
 
 ```bash

benchmarks/tts/bench_tts.py

@@ -84,12 +84,17 @@ def build_bench_args(
     result_filename: str | None,
     extra_cli_args: list[str],
     output_len: int | None = None,
+    served_model_name: str | None = None,
+    num_warmups: int = 2,
+    request_seed: int | None = None,
 ) -> list[str]:
     """Build the ``vllm bench serve --omni`` command for one (task, concurrency) run."""
     dataset_name = _TASK_TO_DATASET[task]
     backend: str = model_cfg["backend"]
     endpoint: str = model_cfg["endpoint"]
-    task_extra_body: dict[str, Any] = (model_cfg.get("task_extra_body") or {}).get(task) or {}
+    task_extra_body: dict[str, Any] = dict((model_cfg.get("task_extra_body") or {}).get(task) or {})
+    if request_seed is not None:
+        task_extra_body["seed"] = request_seed
 
     # Resolve dataset path
     if dataset_path:
@@ -109,7 +114,7 @@ def build_bench_args(
         "--port",
         str(port),
         "--model",
-        model,
+        served_model_name or model,
         "--backend",
         backend,
         "--endpoint",
@@ -119,7 +124,7 @@ def build_bench_args(
         "--num-prompts",
         str(num_prompts),
         "--num-warmups",
-        "2",
+        str(num_warmups),
         "--percentile-metrics",
         "ttft,e2el,audio_rtf,audio_ttfp,audio_duration,audio_underrun",
     ]
@@ -152,7 +157,8 @@ def build_bench_args(
         if result_filename:
             cmd += ["--result-filename", result_filename]
 
-    cmd += extra_cli_args
+    passthrough = extra_cli_args[1:] if extra_cli_args[:1] == ["--"] else extra_cli_args
+    cmd += passthrough
     return cmd
 
 
@@ -225,6 +231,12 @@ def main() -> None:
     parser.add_argument(
         "--model", required=True, help="HuggingFace model ID (e.g. Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice)"
     )
+    parser.add_argument(
+        "--served-model-name",
+        default=None,
+        help="Model name/path accepted by the running server. Use this when --model selects a registry entry "
+        "but the server was launched from a local bundle path.",
+    )
     parser.add_argument("--task", default="all", help="Task type: voice_clone | default_voice | voice_design | all")
     parser.add_argument("--locale", default="en", choices=["en", "zh"])
     parser.add_argument("--concurrency", type=int, nargs="+", default=[1, 4], metavar="N")
@@ -236,6 +248,13 @@ def main() -> None:
         metavar="N",
         help="Number of prompts per run. If one value, applied to all concurrency levels.",
     )
+    parser.add_argument("--num-warmups", type=int, default=2, help="Warmup requests before each measured run")
+    parser.add_argument(
+        "--request-seed",
+        type=int,
+        default=None,
+        help="Optional model sampling seed added to every request body for reproducible quality runs",
+    )
     parser.add_argument(
         "--dataset-path", default=None, help="Root of seed-tts-eval dataset (required for voice_clone/default_voice)"
     )
@@ -256,6 +275,9 @@ def main() -> None:
     parser.add_argument("extra", nargs=argparse.REMAINDER, help="Extra args passed directly to vllm bench serve")
     args = parser.parse_args()
 
+    if args.num_warmups < 0:
+        parser.error("--num-warmups cannot be negative")
+
     model_configs = load_model_configs(Path(args.model_configs))
     if args.model not in model_configs:
         known = "\n  ".join(model_configs.keys())
@@ -308,6 +330,9 @@ def main() -> None:
                 result_filename=result_filename,
                 extra_cli_args=args.extra or [],
                 output_len=args.output_len,
+                served_model_name=args.served_model_name,
+                num_warmups=args.num_warmups,
+                request_seed=args.request_seed,
             )
             result = run_one_benchmark(cmd)
             if result is not None:

benchmarks/tts/model_configs.yaml

@@ -7,6 +7,17 @@
 # is tracked here.
 
 models:
+  IndexTeam/IndexTTS-2.5:
+    supported_tasks: [voice_clone]
+    backend: openai-audio-speech
+    endpoint: /v1/audio/speech
+    trust_remote_code: true
+    task_extra_body:
+      voice_clone:
+        extra_params:
+          lang: en
+          text_normalization: true
+
   # -CustomVoice checkpoints lack speaker_encoder weights, so voice_clone is
   # NOT supported (an attempt raises ValueError from _extract_speaker_embedding
   # at model runtime).  Use -Base for voice_clone.

docker/Dockerfile.ci

@@ -1,7 +1,24 @@
-# Target vllm version: v0.26.0 (releases/v0.26.0 branch).
+# 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
+# base image already ships exactly the target vLLM. Everything the runtime
+# needs — torch, flashinfer, nvJitLink, numpy — comes from that image as one
+# self-consistent set.
+#
+# This block reappears only when the rebase targets a vLLM commit that is NOT a
+# released tag. During the 0.27 rebase, targeting v0.27.0rc1 on top of the
+# v0.26.0 base image required reinstalling vLLM from wheels.vllm.ai and then
+# hand-repairing the fallout: pinning torch ahead of flashinfer (installing it
+# after bound flashinfer's TVM FFI runtime to the old torch and aborted engine
+# 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. 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.26.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

docker/Dockerfile.xpu

@@ -88,7 +88,7 @@ ENV UV_EXTRA_INDEX_URL=${PIP_EXTRA_INDEX_URL}
 ENV UV_INDEX_STRATEGY="unsafe-best-match"
 ENV UV_LINK_MODE="copy"
 
-ARG VLLM_VERSION=v0.26.0
+ARG VLLM_VERSION=v0.27.0
 RUN git clone -b ${VLLM_VERSION} https://github.com/vllm-project/vllm
 WORKDIR /workspace/vllm
 
@@ -108,7 +108,7 @@ ENV VLLM_WORKER_MULTIPROC_METHOD=spawn
 
 RUN --mount=type=cache,target=/root/.cache/uv \
     uv pip uninstall triton triton-xpu && \
-    uv pip install triton-xpu==3.7.1 && \
+    uv pip install triton-xpu==3.7.2 && \
     uv pip install --no-build-isolation --no-deps .
 
 CMD ["/bin/bash"]
@@ -144,12 +144,13 @@ WORKDIR /workspace/vllm-omni
 COPY . .
 
 ENV VLLM_OMNI_TARGET_DEVICE=xpu
+# Keep the upstream oneCCL packages paired with the XPU torch runtime.
 RUN --mount=type=cache,target=/root/.cache/uv \
     uv pip install --no-build-isolation \
     --extra-index-url https://mirrors.ustc.edu.cn/pypi/simple/ \
     ".[dev]" && \
-    uv pip uninstall triton oneccl oneccl-devel && \
-    uv pip install triton-xpu==3.7.1 --reinstall
+    uv pip uninstall triton && \
+    uv pip install triton-xpu==3.7.2 --reinstall
 
 FROM vllm-omni AS vllm-omni-openai
 

docs/.nav.yml

@@ -40,30 +40,12 @@ nav:
   - Models:
     - models/supported_models.md
   - Features:
-    - Sleep Mode: features/sleep_mode.md
-    - Diffusion Features:
-      - Overview: user_guide/diffusion_features.md
-      - Feature Compatibility: user_guide/feature_compatibility.md
-      - Regional Compilation: user_guide/diffusion/regional_compilation.md
-      - Cache Acceleration:
-        - TeaCache: user_guide/diffusion/cache_acceleration/teacache.md
-        - Cache-DiT: user_guide/diffusion/cache_acceleration/cache_dit.md
-      - Attention Backends: user_guide/diffusion/attention_backends.md
-      - Frame Interpolation: user_guide/diffusion/frame_interpolation.md
-      - Parallelism:
-        - Overview: user_guide/diffusion/parallelism/overview.md
-        - CFG Parallel: user_guide/diffusion/parallelism/cfg_parallel.md
-        - Expert Parallel: user_guide/diffusion/parallelism/expert_parallel.md
-        - Hybrid Sharded Data Parallel: user_guide/diffusion/parallelism/hsdp.md
-        - Sequence Parallel: user_guide/diffusion/parallelism/sequence_parallel.md
-        - Tensor Parallel: user_guide/diffusion/parallelism/tensor_parallel.md
-        - VAE Parallelism: user_guide/diffusion/parallelism/vae_parallelism.md
-      - CPU Offloading: user_guide/diffusion/cpu_offload.md
-      - LoRA: user_guide/diffusion/lora.md
-      - Custom Pipeline: features/custom_pipeline.md
-      - Execution Modes: user_guide/diffusion/execution_modes.md
+    - Overview: features/README.md
+    - Runtime and Stage Execution:
+      - Execution Modes and Streaming: user_guide/diffusion/execution_modes.md
+      - Sleep Mode: features/sleep_mode.md
     - Quantization:
-      - Quantization: user_guide/quantization/overview.md
+      - Overview: user_guide/quantization/overview.md
       - Online Quantization: user_guide/quantization/online.md
       - Quantized KV Cache: user_guide/quantization/quantized_kvcache.md
       - FP8 W8A8: user_guide/quantization/fp8.md
@@ -72,9 +54,33 @@ nav:
       - MXFP8 W8A8: user_guide/quantization/mxfp8.md
       - MXFP4 W4A4: user_guide/quantization/mxfp4.md
       - ModelOpt: user_guide/quantization/modelopt.md
-      - GGUF: user_guide/quantization/gguf.md
       - AutoRound: user_guide/quantization/autoround.md
       - msModelSlim: user_guide/quantization/msmodelslim.md
+    - Diffusion Acceleration:
+      - Overview and Compatibility:
+        - Overview: user_guide/diffusion_features.md
+        - Feature Compatibility: user_guide/feature_compatibility.md
+      - CPU Offloading: user_guide/diffusion/cpu_offload.md
+      - Cache Acceleration:
+        - TeaCache: user_guide/diffusion/cache_acceleration/teacache.md
+        - Cache-DiT: user_guide/diffusion/cache_acceleration/cache_dit.md
+      - Parallelism:
+        - Overview: user_guide/diffusion/parallelism/overview.md
+        - CFG Parallel: user_guide/diffusion/parallelism/cfg_parallel.md
+        - Expert Parallel: user_guide/diffusion/parallelism/expert_parallel.md
+        - Hybrid Sharded Data Parallel: user_guide/diffusion/parallelism/hsdp.md
+        - Sequence Parallel: user_guide/diffusion/parallelism/sequence_parallel.md
+        - Tensor Parallel: user_guide/diffusion/parallelism/tensor_parallel.md
+        - VAE Parallelism: user_guide/diffusion/parallelism/vae_parallelism.md
+      - Attention Backends: user_guide/diffusion/attention_backends.md
+      - Regional Compilation: user_guide/diffusion/regional_compilation.md
+      - Frame Interpolation: user_guide/diffusion/frame_interpolation.md
+      - Startup and Loading: user_guide/diffusion/startup_and_loading.md
+      - LoRA: user_guide/diffusion/lora.md
+    - Experimental:
+      - Session State Manager: features/session_state_manager.md
+  - Integrations:
+    - Custom Diffusion Pipeline: features/custom_pipeline.md
     - ComfyUI: features/comfyui.md
   - Fault Tolerance:
     - Failure Modes: user_guide/fault_injection_reliability_matrix.md
@@ -108,6 +114,7 @@ nav:
           - Shared Memory Connector: design/feature/omni_connectors/shared_memory_connector.md
           - Yuanrong Store Connector: design/feature/omni_connectors/yuanrong_connector.md
           - Yuanrong Transfer Engine Connector: design/feature/omni_connectors/yuanrong_transfer_engine_connector.md
+      - Quantization: design/feature/quantization.md
       - Diffusion Acceleration:
         - Parallelism:
           - CFG-Parallel: design/feature/cfg_parallel.md
@@ -117,9 +124,8 @@ nav:
           - Sequence Parallel: design/feature/sequence_parallel.md
           - Tensor Parallel: design/feature/tensor_parallel.md
           - VAE Patch Parallelism: design/feature/vae_parallel.md
-        - Attention Backends:
+        - Attention Optimization:
           - Skip-Softmax: design/feature/skip_softmax.md
-        - Quantization: design/feature/quantization.md
         - Cache-DiT: design/feature/cache_dit.md
         - TeaCache: design/feature/teacache.md
         - Diffusion Continuous Batching: design/feature/diffusion_continuous_batching.md

docs/design/index.md

@@ -11,6 +11,10 @@ in the active navigation.
 
 ## Feature Design Documents
 
+For user-facing configuration and current compatibility, see the
+[Features overview](../features/README.md). A design document defines an
+implementation contract; it is not, by itself, a general support claim.
+
 ### Runtime and stage execution
 
 - [Disaggregated Inference](feature/disaggregated_inference.md)
@@ -30,6 +34,10 @@ in the active navigation.
 - [Yuanrong Store Connector](feature/omni_connectors/yuanrong_connector.md)
 - [Yuanrong Transfer Engine Connector](feature/omni_connectors/yuanrong_transfer_engine_connector.md)
 
+### Quantization
+
+- [Quantization](feature/quantization.md)
+
 ### Diffusion acceleration
 
 #### Parallelism
@@ -42,14 +50,14 @@ in the active navigation.
 - [Tensor Parallel](feature/tensor_parallel.md)
 - [VAE Patch Parallelism](feature/vae_parallel.md)
 
-#### Attention Backends
+#### Attention optimization
+
+The [Diffusion Attention Backends](../user_guide/diffusion/attention_backends.md)
+guide lists all selectable backends and their platform defaults. Skip-Softmax
+is the backend-related optimization with a standalone feature-design contract:
 
 - [Skip-Softmax](feature/skip_softmax.md)
 
-#### Quantization
-
-- [Quantization](feature/quantization.md)
-
 - [Cache-DiT](feature/cache_dit.md)
 - [TeaCache](feature/teacache.md)
 - [Diffusion Continuous Batching](feature/diffusion_continuous_batching.md)

docs/features/README.md

@@ -0,0 +1,67 @@
+# Features
+
+Use this section to choose and configure vLLM-Omni runtime and optimization
+features. The navigation follows the active
+[Feature Design](../design/index.md#feature-design-documents) taxonomy whenever
+an implementation contract has a user-facing workflow.
+
+!!! note "User guides, design documents, and recipes"
+
+    User guides explain how to enable a feature and where it is supported.
+    Design documents define internal contracts and do not, by themselves,
+    imply general or production support. For model-specific launch flags and
+    hardware requirements, use the linked examples and validated recipes from
+    [Supported Models](../models/supported_models.md).
+
+## Runtime and Stage Execution
+
+| Goal | User guide | Related design contract |
+| --- | --- | --- |
+| Choose serial, batched, step-wise, or streaming diffusion execution | [Execution Modes and Streaming](../user_guide/diffusion/execution_modes.md) | [Diffusion Continuous Batching](../design/feature/diffusion_continuous_batching.md), [Async Diffusion Output](../design/feature/async_diffusion_output.md) |
+| Reclaim stage memory without restarting the server | [Sleep Mode](sleep_mode.md) | Runtime lifecycle behavior is documented in the user guide |
+
+Some runtime designs are deliberately not promoted as standalone User Guide
+features yet:
+
+- [Disaggregated Inference](../design/feature/disaggregated_inference.md) and
+  [OmniConnector implementations](../design/index.md#communication) describe
+  topology and transport contracts. Practical deployment configuration remains
+  under [Pipeline and deploy configurations](../configuration/stage_configs.md).
+- [Async Chunk](../design/feature/async_chunk.md) and
+  [Async Omni Output Materialization](../design/feature/omni_async_output_materialization.md)
+  are model- and pipeline-dependent. Use the selected model's deploy
+  configuration and recipe for the supported settings.
+- [Automatic Prefix Caching](../design/feature/prefix_caching.md) remains a
+  design-level contract until its user-facing configuration and compatibility
+  surface is consolidated.
+
+## Quantization
+
+Quantization is a cross-model feature rather than a diffusion-only
+optimization. The unified [`quantization_config` guide](../user_guide/quantization/overview.md)
+covers diffusion-only models, multi-stage omni/TTS models, and multi-stage
+diffusion models. Its [design contract](../design/feature/quantization.md)
+defines the shared configuration and backend extension points.
+
+## Diffusion Acceleration
+
+| Goal | User guide | Related design contract |
+| --- | --- | --- |
+| Compare acceleration methods and supported combinations | [Overview](../user_guide/diffusion_features.md), [Feature Compatibility](../user_guide/feature_compatibility.md) | [Diffusion acceleration designs](../design/index.md#diffusion-acceleration) |
+| Move weights between host and device memory | [CPU Offloading](../user_guide/diffusion/cpu_offload.md) | [Distributed Layerwise Offload](../design/feature/distributed_layerwise_offload.md) |
+| Reuse denoising computation | [Cache Acceleration](../user_guide/diffusion/cache_acceleration/cache_dit.md) | [Cache-DiT](../design/feature/cache_dit.md), [TeaCache](../design/feature/teacache.md) |
+| Distribute diffusion work across devices | [Parallelism](../user_guide/diffusion/parallelism/overview.md) | [Parallelism designs](../design/index.md#parallelism) |
+| Select dense, sparse, or quantized attention paths | [Attention Backends](../user_guide/diffusion/attention_backends.md) | [Skip-Softmax](../design/feature/skip_softmax.md) |
+| Compile repeated diffusion regions | [Regional Compilation](../user_guide/diffusion/regional_compilation.md) | User-facing optimization guide |
+| Add generated video frames | [Frame Interpolation](../user_guide/diffusion/frame_interpolation.md) | User-facing extension guide |
+| Reduce diffusion model startup time | [Startup and Loading](../user_guide/diffusion/startup_and_loading.md) | User-facing loading guide |
+| Apply diffusion adapters | [LoRA](../user_guide/diffusion/lora.md) | User-facing extension guide |
+
+The [Pipeline Parallelism guide](../user_guide/diffusion/parallelism/pipeline_parallel.md)
+remains available by direct link, but it is not promoted in the primary User
+Guide navigation until its user-facing support and placement are settled.
+
+## Experimental
+
+[Session State Manager](session_state_manager.md) is opt-in and experimental.
+Its APIs and compatibility may change without notice.

docs/models/supported_models.md

@@ -80,6 +80,7 @@ th {
 | `HiggsAudioV2ForConditionalGeneration` | Higgs-Audio v2 | `bosonai/higgs-audio-v2-generation-3B-base` | ✅︎ | | | | — |
 | `HiggsMultimodalQwen3ForConditionalGeneration` | Higgs-Audio v3 (TTS) | `bosonai/higgs-audio-v3-tts-4b` | ✅︎ | | | | [Published](https://recipes.vllm.ai/bosonai/higgs-audio-v3-tts-4b) |
 | `IndexTTS2TalkerForConditionalGeneration` | IndexTTS-2 | `IndexTeam/IndexTTS-2` | ✅︎ | | | | — |
+| `IndexTTS25TalkerForConditionalGeneration` | IndexTTS-2.5 | native `checkpoints/` bundle | ✅︎ | | | | [Repository](https://github.com/vllm-project/vllm-omni/blob/main/recipes/IndexTeam/IndexTTS-2_5.md) |
 | `NextStep11Pipeline` | NextStep-1.1 | `stepfun-ai/NextStep-1.1` | ✅︎ | ✅︎ | | ✅︎ | — |
 | `MiMoAudioModel` | MiMo-Audio-7B-Instruct | `XiaomiMiMo/MiMo-Audio-7B-Instruct` | ✅︎ | ✅︎ | | | — |
 | `MiMoV2ASRForCausalLM` | MiMo-V2.5-ASR | `XiaomiMiMo/MiMo-V2.5-ASR` | ✅︎ | ✅︎ | | | — |

docs/user_guide/diffusion/lora.md

@@ -1,14 +1,18 @@
 # LoRA (Low-Rank Adaptation) Guide
 
-LoRA (Low-Rank Adaptation) enables fine-tuning diffusion models by adding trainable low-rank matrices to existing model weights. vLLM-Omni currently supports PEFT-style LoRA adapters, allowing you to customize model behavior without modifying the base model weights.
+LoRA (Low-Rank Adaptation) enables fine-tuning diffusion models by adding trainable low-rank matrices to existing model weights. vLLM-Omni supports two LoRA backends: **PEFT** for PEFT-style adapters, and **Distill** usually for few-steps inference. **PEFT** backend allows you to customize model behavior without modifying the base model weights. **Distill** backend fuses LoRA weights into the base model at initialization.
 
 ## Overview
 
-LoRA adapters are lightweight, model-specific fine-tuning weights that can be dynamically loaded and applied to diffusion models. vLLM-Omni uses a unified LoRA handling mechanism similar to vLLM with LRU cache management.
+LoRA adapters are lightweight, model-specific fine-tuning weights that can be applied to diffusion models in two ways:
+
+- **PEFT backend** (`--lora-backend peft`, default): Loads a PEFT-format adapter folder via `DiffusionLoRAManager`. Adapters are cached (LRU) and activated per request via `LoRARequest`. It uses a unified LoRA handling mechanisms similar to vLLM with LRU cache management.
+- **Distill backend** (`--lora-backend distill`): Calls `pipeline.load_lora_weights` once at initialization to fuse one or more concrete checkpoint files directly into the base weights. Typically used for distilled few-step LoRAs (e.g. Lightning, LightX2V).
 
 ## LoRA Adapter Format
 
-LoRA adapters must be in **PEFT (Parameter-Efficient Fine-Tuning)** format. A typical LoRA adapter directory structure:
+### PEFT (Parameter-Efficient Fine-Tuning) format (default)
+A typical PEFT-format LoRA adapter directory structure:
 
 ```
 lora_adapter/
@@ -25,19 +29,20 @@ The `adapter_config.json` file contains metadata about the LoRA adapter, includi
 
 ### Offline Inference
 
-#### Pre-loaded LoRA
+#### PEFT backend: pre-loaded LoRA
 
-Load a LoRA adapter at initialization. This adapter is pre-loaded into the cache and can be activated by requests:
+Load a PEFT-format LoRA adapter at initialization. The adapter is pre-loaded into the cache and can be activated per request:
 
 ```python
 from vllm_omni import Omni
 from vllm_omni.lora.request import LoRARequest
 
-lora_path="/path/to/lora_adapter"
+lora_path = "/path/to/lora_adapter"
 
 omni = Omni(
     model="stabilityai/stable-diffusion-3.5-medium",
-    lora_path=lora_path
+    lora_path=lora_path,
+    lora_backend="peft",  # default, can be omitted
 )
 
 lora_request = LoRARequest(
@@ -53,6 +58,98 @@ outputs = omni.generate(
 )
 ```
 
+#### Distill backend: fuse distilled LoRA at init
+
+For distilled few-step LoRAs, pass `lora_backend="distill"` together with one or more concrete `.safetensors` files. The weights are fused into the base model once at init; subsequent `generate()` calls do not need a `LoRARequest`.
+
+##### Supported pipelines
+
+For Qwen-Image and Wan pipelines, the distill backend calls `pipeline.load_lora_weights(...)` during worker initialization.
+
+| Pipeline | Supported distilled LoRA repo | Notes |
+|----------|--------------------------------|-------|
+| `QwenImagePipeline` | `lightx2v/Qwen-Image-2512-Lightning` | Used with Qwen-Image-2512 Lightning-style few-step inference. |
+| `Wan22Pipeline` | `lightx2v/Wan2.1-Distill-Loras`, `lightx2v/Wan2.2-Distill-Loras` | Wan2.1 uses one LoRA file. For dual-transformer Wan2.2 MoE, pass high-noise then low-noise LoRA files. |
+| `Wan22I2VPipeline` | `lightx2v/Wan2.2-Distill-Loras` | For dual-transformer Wan2.2 MoE, pass high-noise then low-noise LoRA files. |
+
+Other diffusion pipelines are not currently listed as supporting distilled LoRA. Use the PEFT backend for request-time adapters, or bake converted weights into a local Diffusers directory before serving.
+
+Single-file example (Qwen-Image-Lightning):
+
+```python
+from vllm_omni import Omni
+
+omni = Omni(
+    model="Qwen/Qwen-Image-2512",
+    lora_path="/path/to/Qwen-Image-2512-Lightning.safetensors",
+    lora_backend="distill",
+)
+
+outputs = omni.generate(prompt="A piece of cheesecake")
+```
+
+Multi-file example (Wan2.2 MoE, high + low noise):
+
+```python
+from vllm_omni import Omni
+
+omni = Omni(
+    model="Wan-AI/Wan2.2-T2V-A14B-Diffusers",
+    lora_path=[
+        "/path/to/wan2.2_high_noise_lora.safetensors",   # -> transformer
+        "/path/to/wan2.2_low_noise_lora.safetensors",    # -> transformer_2
+    ],
+    lora_backend="distill",
+)
+```
+
+The CLI examples under `examples/offline_inference/` accept the same flags, e.g.:
+
+```bash
+python examples/offline_inference/text_to_video/text_to_video.py \
+  --model Wan-AI/Wan2.2-T2V-A14B-Diffusers \
+  --lora-backend distill \
+  --lora-path /path/to/high.safetensors /path/to/low.safetensors \
+  --prompt "A cat playing with yarn"
+```
+
+##### Online serving
+
+Distilled LoRAs can also be fused when an online diffusion server starts. The
+adapter remains active for the lifetime of that server, so requests do not pass
+a per-request `lora` field.
+
+```bash
+vllm serve Qwen/Qwen-Image-2512 \
+  --omni \
+  --port 8091 \
+  --lora-backend distill \
+  --lora-path /path/to/Qwen-Image-2512-Lightning-4steps.safetensors
+```
+
+Then send a normal generation request with the sampling settings expected by
+the distilled checkpoint:
+
+```bash
+curl -s http://localhost:8091/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "messages": [
+      {"role": "user", "content": "A Chinese female college student, around 20 years old, with a very short haircut that conveys a gentle, artistic vibe. Her hair naturally falls to partially cover her cheeks, projecting a tomboyish yet charming demeanor. She has cool-toned fair skin and delicate features, with a slightly shy yet subtly confident expression—her mouth crooked in a playful, youthful smirk. She wears an off-shoulder top, revealing one shoulder, with a well-proportioned figure. The image is framed as a close-up selfie: she dominates the foreground, while the background clearly shows her dormitory—a neatly made bed with white linens on the top bunk, a tidy study desk with organized stationery, and wooden cabinets and drawers. The photo is captured on a smartphone under soft, even ambient lighting, with natural tones, high clarity, and a bright, lively atmosphere full of youthful, everyday energy."}
+    ],
+    "extra_body": {
+      "height": 1024,
+      "width": 1024,
+      "num_inference_steps": 4,
+      "true_cfg_scale": 1.0,
+      "seed": 42
+    }
+  }' | jq -r '.choices[0].message.content[0].image_url.url' | cut -d',' -f2 | base64 -d > qwen_image_distill_lora_output.png
+```
+
+For Wan2.2 MoE serving, pass the high-noise checkpoint first and the low-noise
+checkpoint second to `--lora-path`.
+
 !!! note "Server-side Path Requirement"
     The LoRA adapter path (`local_path`) must be readable on the **server** machine. If your client and server are on different machines, ensure the LoRA adapter is accessible via a shared mount or copied to the server.
 
@@ -141,6 +238,7 @@ Notes:
 
 - This route avoids runtime LoRA loading changes in vLLM-Omni when you choose to bake converted weights into a local Diffusers directory.
 - Output quality and speed depend on the replacement checkpoints and sampling params you choose.
+- If you only need to fuse distilled LoRAs into a Wan2.2 checkpoint at load time (without the full LightX2V convert + assemble pipeline), you can instead pass them directly via `--lora-backend distill --lora-path <high>.safetensors <low>.safetensors`. See the [Distill backend](#distill-backend-fuse-distilled-lora-at-init) section above.
 
 
 ## See Also

docs/user_guide/diffusion/startup_and_loading.md

@@ -0,0 +1,60 @@
+# Diffusion Startup and Loading
+
+Large diffusion models can take several minutes to load at startup. vLLM-Omni
+loads safetensors shards in parallel to reduce this initialization time.
+
+Multi-thread weight loading is enabled by default with four threads. No
+configuration is needed for the default behavior.
+
+## Configuration
+
+| Parameter | CLI flag | Default | Description |
+| --- | --- | --- | --- |
+| `enable_multithread_weight_load` | `--disable-multithread-weight-load` | `True` | Pass the flag to disable multi-thread loading |
+| `num_weight_load_threads` | `--num-weight-load-threads` | `4` | Number of parallel weight-loading threads |
+
+!!! tip
+
+    The default balances startup speed and disk I/O contention. Fast NVMe
+    storage may benefit from more threads, while network storage or hard disks
+    may not.
+
+## Online Serving
+
+```bash
+# Default: multi-thread loading with four threads
+vllm serve Qwen/Qwen-Image --omni --port 8091
+
+# Increase the thread count
+vllm serve Wan-AI/Wan2.2-I2V-A14B-Diffusers --omni \
+  --num-weight-load-threads 8
+
+# Disable multi-thread loading
+vllm serve Qwen/Qwen-Image --omni --disable-multithread-weight-load
+```
+
+## Offline Inference
+
+```python
+from vllm_omni import Omni
+
+# Default: multi-thread loading with four threads
+omni = Omni(model="Qwen/Qwen-Image")
+
+# Increase the thread count
+omni = Omni(
+    model="Wan-AI/Wan2.2-I2V-A14B-Diffusers",
+    num_weight_load_threads=8,
+)
+```
+
+## Reference Benchmarks
+
+The following measurements were collected on NVIDIA H800 hardware. Treat them
+as reference results rather than a guarantee for other storage or hardware
+configurations.
+
+| Model | Sequential loading | Multi-thread loading | Speedup |
+| --- | ---: | ---: | ---: |
+| **Qwen/Qwen-Image** (53.7 GiB) | 168 s | 27 s | **6.2x** |
+| **Wan-AI/Wan2.2-I2V-A14B-Diffusers** (64.5 GiB) | 283 s | 56 s | **5.1x** |

docs/user_guide/diffusion_features.md

@@ -49,7 +49,7 @@ Parallelism methods distribute computation across GPUs without quality loss (mat
 
 | Method | Description | Best For |
 |--------|-------------|----------|
-| **[Multi-Thread Weight Loading](#multi-thread-weight-loading)** | Loads safetensors shards in parallel using a thread pool | All diffusion models; reduces startup from minutes to seconds |
+| **[Multi-Thread Weight Loading](diffusion/startup_and_loading.md)** | Loads safetensors shards in parallel using a thread pool | All diffusion models; reduces startup from minutes to seconds |
 
 **Note:** Some acceleration methods can be combined together for optimized performance. See [Feature Compatibility Table](#feature-compatibility) and [Feature Compatibility Tutorial](feature_compatibility.md) for detailed configuration examples.
 
@@ -100,7 +100,9 @@ The following tables show which models support each feature:
 
 - **🔀SP (Ulysses & Ring)**: Includes both Ulysses-SP and Ring-Attention methods
 - ✅ = Fully supported
+- ✅* = Supported with the constraint listed below the table
 - ❌ = Not supported
+- ❓ = Not verified; not recommended
 
 > Notes:
 
@@ -119,7 +121,7 @@ The following tables show which models support each feature:
 | **FLUX.2-dev**           |     ✅     |     ✅      |           ✅           |       ✅        |         ✅         |          ❌          |   ✅    |             ✅             |          ✅           |       ❌        |        ❌         |
 | **GLM-Image**            |     ❌     |     ❌      |           ❌           |       ✅        |         ✅         |          ❌          |   ✅    |             ❌             |          ❌           |       ❌        |        ❌         |
 | **Hidream-I1-Full**        |     ❌     |     ❌      |           ❌           |       ❌        |         ✅         |          ❌          |   ❌    |             ❌             |          ❌           |       ❌        |        ❌         |
-| **HunyuanImage3**        |     ❌     |     ✅      |           ❌           |       ❌        |         ✅         |          ❌          |   ❌    |             ❌             |          ❌           |       ✅        |        ❌         |
+| **HunyuanImage3**        |     ❌     |     ✅      |           ❌           |       ❌        |         ✅         |          ❌          |   ❌    |             ❌             |          ❌           |       ✅        |        ✅*        |
 | **Krea 2**               |     ❌     |     ✅      |           ❌           |       ❌        |         ❌         |          ❌          |   ✅    |             ✅             |      ✅ (decode)      |       ❌        |        ❌         |
 | **LongCat-Image**        |     ✅     |     ✅      |           ✅           |       ✅        |         ✅         |          ❌          |   ❌    |             ✅             |          ❌           |       ❌        |        ❌         |
 | **LongCat-Image-Edit**   |     ✅     |     ✅      |           ✅           |       ✅        |         ✅         |          ❌          |   ❌    |             ✅             |          ❌           |       ❌        |        ❌         |
@@ -145,6 +147,7 @@ The following tables show which models support each feature:
 > 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).
 
 ### VideoGen
 
@@ -155,13 +158,16 @@ The following tables show which models support each feature:
 | **Wan2.1-VACE**              |     ❌     |     ✅      |           ✅           |       ✅        |         ✅         |         ❌         |   ✅    |             ✅             |      ✅ (decode)      |       ❌        |        ❌         |
 | **LTX-2**                    |     ❌     |     ✅      |           ✅           |       ✅        |         ✅         |         ❌         |   ✅    |             ✅             |      ✅ (decode)      |       ❌        |        ❌         |
 | **LTX-2.3**                  |     ❌     |     ✅      |           ✅           |       ✅        |         ✅         |         ❌         |   ✅    |             ✅             |      ✅ (decode)      |       ❌        |        ❌         |
-| **Helios**                   |     ❌     |     ✅      |           ✅           |       ✅        |         ✅         |         ❌         |   ✅    |             ✅             |          ❌           |       ❌        |        ❌         |
+| **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)      |        ❌         |
 
+> **Step execution note:** Helios supports single-request step execution only;
+> use `max_num_seqs=1`.
+
 **Frame Interpolation Support**
 
 - **Supported**: Wan2.2 text-to-video, image-to-video, and TI2V pipelines
@@ -190,7 +196,7 @@ The following tables show which models support each feature:
 | **🔀Ring-Attn** | ✅ | ✅ | ✅ | | | | | | | | | | | |
 | **🔀CFG-Parallel** | ✅ | ✅ | ✅ | ✅ | | | | | | | | | | |
 | **🔀Tensor Parallel** | ✅ | ✅ | ✅ | ✅ | ✅ | | | | | | | | | |
-| **🔀HSDP** | ❓ | ❓ | ❓ | ❓ | ❓ | ❌ | | | | | | | | |
+| **🔀HSDP** | ❓ | ❓ | ✅ | ❓ | ✅ | ❌ | | | | | | | | |
 | **🔀Expert Parallel** | ❓ | ❓ | ❓ | ❓ | ❓ | ❓ | ❓ | | | | | | | |
 | **💾CPU Offloading (Layerwise)** | ✅ | ✅ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | | | | | | |
 | **💾CPU Offloading (Module-wise)** | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ❓ | ❓ | ❌ | | | | | |
@@ -201,97 +207,43 @@ The following tables show which models support each feature:
 
 !!! info
 
-    1. Tensor Parallel and HSDP are not compatible.
+    1. HSDP can be combined with Ulysses-SP or CFG-Parallel. Tensor Parallel
+       and HSDP are not compatible; other HSDP combinations in the table
+       remain unverified.
     2. TeaCache and Cache-DiT are not compatible.
     3. CPU Offloading (Layerwise) and CPU Offloading (Module-wise) are not compatible.
-    4. CPU Offloading (Layerwise) supports single-card for now.
-    5. Using FP8-Quant as an example of qunatization methods.
+    4. The CPU Offloading (Layerwise) row describes local layerwise offload.
+       Multi-device Distributed Layerwise Offload has a separate topology and
+       compatibility matrix in the [CPU Offloading guide](diffusion/cpu_offload.md#distributed-layerwise-offloading).
+    5. The compatibility matrix uses FP8 as the representative quantization method.
     6. Step Execution is not compatible with any diffusion cache backend. LoRA is supported, but each scheduled batch must use a single adapter (requests with different `lora_request` or `lora_scale` are kept in separate batches).
 
 
 ## Multi-Thread Weight Loading
 
-Large diffusion models can take several minutes to load weights at startup (e.g., ~3 min for Qwen-Image, ~5 min for Wan2.2 I2V 14B). Multi-thread weight loading speeds up this process by loading safetensors shards in parallel using a thread pool instead of sequentially.
-
-This optimization is **enabled by default** with 4 threads. No configuration is needed for the default behavior.
-
-### Configuration
-
-| Parameter | CLI Flag | Default | Description |
-|-----------|----------|---------|-------------|
-| `enable_multithread_weight_load` | `--disable-multithread-weight-load` | `True` (enabled) | Pass the flag to disable multi-thread loading |
-| `num_weight_load_threads` | `--num-weight-load-threads` | `4` | Number of threads for parallel weight loading |
-
-!!! tip
-    The default of 4 threads balances speed and disk I/O contention. On fast NVMe storage you may benefit from more threads (e.g., 8). On HDD or network storage, the default of 4 avoids saturating I/O bandwidth.
-
-### Online Serving
-
-```bash
-# Default (multi-thread enabled, 4 threads)
-vllm serve Qwen/Qwen-Image --omni --port 8091
-
-# Custom thread count
-vllm serve Wan-AI/Wan2.2-I2V-A14B-Diffusers --omni --num-weight-load-threads 8
-
-# Disable multi-thread loading
-vllm serve Qwen/Qwen-Image --omni --disable-multithread-weight-load
-```
-
-### Offline Inference
-
-```python
-from vllm_omni import Omni
-
-# Default (multi-thread enabled, 4 threads)
-omni = Omni(model="Qwen/Qwen-Image")
-
-# Custom thread count
-omni = Omni(
-    model="Wan-AI/Wan2.2-I2V-A14B-Diffusers",
-    num_weight_load_threads=8,
-)
-```
-
-### Benchmarks
-
-Measured on NVIDIA H800:
-
-| Model | Before | After | Speedup |
-|-------|--------|-------|---------|
-| **Qwen/Qwen-Image** (53.7 GiB) | 168s | 27s | **6.2x** |
-| **Wan-AI/Wan2.2-I2V-A14B-Diffusers** (64.5 GiB) | 283s | 56s | **5.1x** |
+The loading guide now lives at [Diffusion Startup and
+Loading](diffusion/startup_and_loading.md). This heading remains so existing
+links to this section continue to work.
 
 ## Learn More
 
-**Cache Acceleration:**
+The Diffusion Acceleration navigation groups the remaining guides as follows:
 
-- **[TeaCache Configuration Guide](diffusion/cache_acceleration/teacache.md)** - Parameter tuning, performance tips, troubleshooting
-- **[Cache-DiT Advanced Guide](diffusion/cache_acceleration/cache_dit.md)** - DBCache, TaylorSeer, SCM techniques and optimization
+| Area | Guide |
+| --- | --- |
+| Compatibility | [Feature Compatibility](feature_compatibility.md) |
+| CPU offloading | [CPU Offloading](diffusion/cpu_offload.md) |
+| Cache acceleration | [TeaCache](diffusion/cache_acceleration/teacache.md), [Cache-DiT](diffusion/cache_acceleration/cache_dit.md) |
+| Parallelism | [Parallelism Overview](diffusion/parallelism/overview.md) |
+| Attention | [Attention Backends](diffusion/attention_backends.md) |
+| Compilation | [Regional Compilation](diffusion/regional_compilation.md) |
+| Video extension | [Frame Interpolation](diffusion/frame_interpolation.md) |
+| Startup | [Startup and Loading](diffusion/startup_and_loading.md) |
+| Adapters | [LoRA](diffusion/lora.md) |
 
-**Parallelism Methods:**
+Related cross-model and runtime features are documented separately:
 
-- **[Parallelism Overview](diffusion/parallelism/overview.md)** - Tensor Parallelism, Sequence Parallelism, CFG Parallelism, Pipeline Parallelism, HSDP, and Expert Parallelism
-
-**Memory Optimization:**
-
-- **[CPU Offload Guide](diffusion/cpu_offload.md)** - Offload model components to CPU, reduce GPU memory usage
-- **[VAE Parallelism Guide](diffusion/parallelism/vae_parallelism.md)** - Distribute VAE decode work across GPUs for high-resolution images and videos
-- **[Quantization](quantization/overview.md)** - Quantization methods for diffusion, multi-stage omni/TTS, and multi-stage diffusion models
-
-**Extensions:**
-
-- **[LoRA Inference Guide](diffusion/lora.md)** - Low-Rank Adaptation for style customization and fine-tuning
-- **[Frame Interpolation Guide](diffusion/frame_interpolation.md)** - Worker-side post-generation video frame interpolation for smoother motion
-
-**Execution Modes:**
-
-- **[Diffusion Execution Modes](diffusion/execution_modes.md)** - Configure request batching, step execution, continuous batching, and streaming output
-
-**Startup Optimization:**
-
-- **[Multi-Thread Weight Loading](#multi-thread-weight-loading)** - Speed up model startup by loading safetensors shards in parallel
-
-**Advanced Topics:**
-
-- **[Feature Compatibility](feature_compatibility.md)** - How to combine multiple features for maximum performance
+- [Quantization](quantization/overview.md) covers diffusion-only models,
+  multi-stage omni/TTS models, and multi-stage diffusion models.
+- [Execution Modes and Streaming](diffusion/execution_modes.md) covers the
+  diffusion runtime, including batching, step execution, and streaming output.

docs/user_guide/examples/offline_inference/text_to_image.md

@@ -88,8 +88,9 @@ python text_to_image.py \
 | `--vae-use-tiling` | flag | off | Enable VAE tiling for memory optimization |
 | `--cfg-parallel-size` | int | `1` | Set to `2` to enable CFG Parallel |
 | `--enable-cpu-offload` | flag | off | Enable CPU offloading for diffusion models |
-| `--lora-path` | str | — | Path to PEFT LoRA adapter folder |
+| `--lora-path` | str | — | Path to PEFT LoRA adapter folder or checkpoint file |
 | `--lora-scale` | float | `1.0` | Scale factor for LoRA weights |
+| `--lora-backend` | str |`"peft"`| LoRA backend for loading LoRA adapters. Default: peft. Available options: peft, distill |
 
 **NextStep-1.1 specific arguments:**
 

docs/user_guide/examples/offline_inference/text_to_video.md

@@ -125,6 +125,9 @@ python text_to_video.py \
 - `--audio-sample-rate`: fallback audio sample rate when the pipeline returns audio.
 - `--quantization`: quantization method (`fp8` for FP8, `gguf` for GGUF).
 - `--flow-shift`: scheduler flow_shift parameter.
+- `--lora-path`: path to PEFT LoRA adapter folder or checkpoint file.
+- `--lora-scale`: scale factor for LoRA weights.
+- `--lora-backend`: backend for loading LoRA adapters. Default: peft. Available options: peft, distill.
 
 ### Wan2.2-specific
 

docs/user_guide/quantization/overview.md

@@ -12,20 +12,20 @@ For the internal architecture and backend extension points, see the
 
 | Mode | Guide | Description | Methods |
 |------|-------|-------------|---------|
-| Online quantization | [Online Quantization](online.md) | vLLM-Omni computes quantized weights and scales while loading the model. | FP8 W8A8, Int8 W8A8, MXFP8 W8A8, MXFP4 W4A4 |
+| Online quantization | [Online Quantization](online.md) | vLLM-Omni computes quantized weights and scales while loading the model. | FP8 W8A8, Int8 W8A8, BitsAndBytes W4, MXFP8 W8A8, MXFP4 W4A4 |
 | Runtime attention quantization | [Quantized KV Cache](quantized_kvcache.md) | vLLM-Omni dynamically quantizes eligible diffusion Flash Attention tensors during inference. | FP8 FA |
-| Pre-quantized checkpoints | Method-specific guides | The checkpoint or an offline quantizer provides quantized weights and scales before serving. | ModelOpt, GGUF, AutoRound, msModelSlim, serialized Int8, offline MXFP8, offline MXFP4 DualScale |
+| Pre-quantized checkpoints | Method-specific guides | The checkpoint or an offline quantizer provides quantized weights and scales before serving. | ModelOpt, AutoRound, msModelSlim, serialized Int8, offline MXFP8, offline MXFP4 DualScale |
 
 ## Hardware Support
 
-| Device | FP8 W8A8 | Int8 W8A8 | ModelOpt | MXFP8 W8A8 | MXFP4 W4A4 | GGUF | AutoRound | msModelSlim |
-|--------|----------|-----------|----------|------------|------------|------|-----------|-------------|
-| NVIDIA Blackwell GPU (SM 100+) | ✅ | ✅ | ✅ | ⭕ | ⭕ | ✅ | ✅ | ❌ |
-| NVIDIA Ada/Hopper GPU (SM 89+) | ✅ | ✅ | ✅ | ⭕ | ⭕ | ✅ | ✅ | ❌ |
-| NVIDIA Ampere GPU (SM 80+) | ✅ | ✅ | ⭕ | ⭕ | ⭕ | ✅ | ✅ | ❌ |
-| AMD ROCm | ⭕ | ⭕ | ⭕ | ⭕ | ✅ | ⭕ | ⭕ | ❌ |
-| Intel XPU | ⭕ | ⭕ | ⭕ | ⭕ | ⭕ | ⭕ | ✅ | ❌ |
-| Ascend NPU | ❌ | ✅ | ❌ | ✅ | ✅ | ❌ | ❌ | ✅ |
+| Device | FP8 W8A8 | Int8 W8A8 | BitsAndBytes W4 | ModelOpt | MXFP8 W8A8 | MXFP4 W4A4 | AutoRound | msModelSlim |
+|--------|----------|-----------|------------------|----------|------------|------------|-----------|-------------|
+| NVIDIA Blackwell GPU (SM 100+) | ✅ | ✅ | ✅ | ✅ | ⭕ | ⭕ | ✅ | ❌ |
+| NVIDIA Ada/Hopper GPU (SM 89+) | ✅ | ✅ | ✅ | ✅ | ⭕ | ⭕ | ✅ | ❌ |
+| NVIDIA Ampere GPU (SM 80+) | ✅ | ✅ | ✅ | ⭕ | ⭕ | ⭕ | ✅ | ❌ |
+| AMD ROCm | ⭕ | ⭕ | ❌ | ⭕ | ⭕ | ✅ | ⭕ | ❌ |
+| Intel XPU | ⭕ | ⭕ | ❌ | ⭕ | ⭕ | ⭕ | ✅ | ❌ |
+| Ascend NPU | ❌ | ✅ | ❌ | ❌ | ✅ | ✅ | ❌ | ✅ |
 
 Legend: `✅` supported, `❌` unsupported, `⭕` not verified in this
 guide. FP8 on Ampere may use a weight-only path where available.
@@ -43,10 +43,10 @@ otherwise.
 |--------|-------|------|----------------|--------|
 | FP8 W8A8 | [FP8](fp8.md) | Online W8A8 or checkpoint FP8 | Qwen-Image; Wan2.2 is not validated | Validated for Qwen-Image family and other DiT models |
 | Int8 W8A8 | [Int8](int8.md) | Online or serialized W8A8 | Qwen-Image; Wan2.2 is not validated | Validated for Qwen-Image and Z-Image |
+| BitsAndBytes W4 | [BitsAndBytes](bitsandbytes.md) | Online W4 weight-only | Z-Image-Turbo; Qwen-Image/Wan2.2 not validated | Validated for Z-Image-Turbo |
 | ModelOpt | [ModelOpt](modelopt.md) | Pre-quantized FP8 checkpoints | Qwen-Image, Z-Image, FLUX.2, HunyuanImage-3.0 | Validated for ModelOpt FP8 diffusion checkpoints |
 | MXFP8 W8A8 | [MXFP8](mxfp8.md) | Online W8A8 or offline pre-quantized | Wan2.2-T2V-A14B, I2V-A14B, TI2V-5B | Ascend NPU only; validated for Wan2.2 |
 | MXFP4 W4A4 | [MXFP4](mxfp4.md) | `mxfp4`: online single-scale only; `mxfp4_dualscale`: online or offline dual-scale (offline recommended) | Wan2.2-T2V-A14B, I2V-A14B | Ascend NPU only; validated for Wan2.2 A14B cascade models; TI2V-5B not supported; offline `mxfp4_dualscale` uses calibrated `mul_scale` for best accuracy |
-| GGUF | [GGUF](gguf.md) | Pre-quantized transformer weights | Qwen-Image | Validated where a model-specific GGUF adapter exists |
 | AutoRound | [AutoRound](autoround.md) | Pre-quantized W4A16 checkpoints | FLUX.1-dev; Qwen-Image/Wan2.2 not validated | Checkpoint-driven |
 | msModelSlim | [msModelSlim](msmodelslim.md) | Pre-quantized Ascend checkpoints | Wan2.2 recipe; HunyuanImage-3.0 inference target | Ascend/NPU path |
 
@@ -61,9 +61,9 @@ in BF16 unless the model guide explicitly adds support.
 |--------|-------|-------|----------------|--------|
 | ModelOpt | [ModelOpt](modelopt.md) | Thinker or language-model checkpoint config | Qwen3-Omni thinker | ModelOpt checkpoint path |
 | Int8 | [Int8](int8.md) | Not currently validated for omni/TTS stages | Qwen3-Omni, Qwen3-TTS | Not validated |
+| BitsAndBytes | [BitsAndBytes](bitsandbytes.md) | Not currently validated for omni/TTS stages | Qwen3-Omni, Qwen3-TTS | Not validated |
 | MXFP8 | [MXFP8](mxfp8.md) | Not currently validated for omni/TTS stages | Qwen3-Omni, Qwen3-TTS | Not validated |
 | MXFP4 | [MXFP4](mxfp4.md) | Not currently validated for omni/TTS stages | Qwen3-Omni, Qwen3-TTS | Not validated |
-| GGUF | [GGUF](gguf.md) | Not currently validated for omni/TTS stages | Qwen3-Omni, Qwen3-TTS | Not validated |
 | AutoRound | [AutoRound](autoround.md) | Thinker or language-model checkpoint config | Qwen2.5-Omni, Qwen3-Omni | Supported through AutoRound checkpoints |
 | msModelSlim | [msModelSlim](msmodelslim.md) | Not currently validated for omni/TTS stages | Qwen3-Omni, Qwen3-TTS | Not validated |
 
@@ -76,10 +76,10 @@ attached to the intended stage rather than applied globally.
 |--------|-------|-------|----------------|--------|
 | FP8 | [FP8](fp8.md) | Stage-specific DiT or transformer module | BAGEL, GLM-Image | Requires model-specific validation |
 | Int8 | [Int8](int8.md) | Stage-specific DiT or transformer module | BAGEL, GLM-Image | Requires model-specific validation |
+| BitsAndBytes | [BitsAndBytes](bitsandbytes.md) | Stage-specific transformer or DiT module | BAGEL, GLM-Image | Not validated |
 | ModelOpt | [ModelOpt](modelopt.md) | Checkpoint-defined diffusion stage | BAGEL, GLM-Image | Requires model-specific validation |
 | MXFP8 | [MXFP8](mxfp8.md) | Stage-specific DiT or transformer module | BAGEL, GLM-Image | Not validated |
 | MXFP4 | [MXFP4](mxfp4.md) | Stage-specific DiT or transformer module | BAGEL, GLM-Image | Not validated |
-| GGUF | [GGUF](gguf.md) | Stage-specific transformer weights | BAGEL, GLM-Image | No validated adapter listed |
 | AutoRound | [AutoRound](autoround.md) | Checkpoint-defined stage | BAGEL, GLM-Image | No validated checkpoint listed |
 | msModelSlim | [msModelSlim](msmodelslim.md) | Ascend-generated stage weights | GLM-Image | Requires model-specific adaptation |
 
@@ -106,7 +106,7 @@ config = build_quant_config({
 
 | Component | Default quantized? | Notes |
 |-----------|--------------------|-------|
-| Diffusion transformer | Yes | Primary target for FP8, Int8, ModelOpt, MXFP8, MXFP4, GGUF, AutoRound, and msModelSlim |
+| Diffusion transformer | Yes | Primary target for FP8, Int8, BitsAndBytes, ModelOpt, MXFP8, MXFP4, AutoRound, and msModelSlim |
 | Text encoder | No | Keep BF16 unless a method-specific guide documents support |
 | VAE | No | Keep BF16; storage-only paths are method-specific |
 | Scheduler/tokenizer | No | Loaded from the base model repository |
@@ -139,8 +139,8 @@ from vllm_omni.quantization import build_quant_config
 
 build_quant_config("fp8")
 build_quant_config({"method": "fp8", "activation_scheme": "static"})
+build_quant_config("bitsandbytes")
 build_quant_config("auto-round", bits=4, group_size=128)
-build_quant_config({"method": "gguf", "gguf_model": "/path/to/model.gguf"})
 build_quant_config({"transformer": {"method": "fp8"}, "vae": None})
 build_quant_config(None)
 ```

examples/offline_inference/aura_omni/end2end.py

@@ -131,7 +131,7 @@ def build_sampling_params() -> list[SamplingParams]:
 
 
 def save_stage_output(stage_outputs, output_dir: str) -> None:
-    output = stage_outputs.request_output
+    output = stage_outputs
     request_id = output.request_id
     if stage_outputs.final_output_type == "text":
         text_output = output.outputs[0].text

examples/offline_inference/covo_audio/end2end.py

@@ -104,7 +104,7 @@ def main(args):
     os.makedirs(output_dir, exist_ok=True)
 
     for stage_outputs in omni_outputs:
-        output = stage_outputs.request_output
+        output = stage_outputs
         if stage_outputs.final_output_type == "text":
             request_id = output.request_id
             text_output = output.outputs[0].text

examples/offline_inference/custom_pipeline/image_to_image/image_edit.py

@@ -228,7 +228,7 @@ async def main():
     if not outputs:
         raise ValueError("No output produced from omni.generate()")
 
-    first_out = outputs[0].request_output
+    first_out = outputs[0]
     req_out: OmniRequestOutput = first_out
 
     # Verify trajectory data (from custom pipeline)

examples/offline_inference/dynin_omni/end2end.py

@@ -741,7 +741,7 @@ def make_mmu_prompt(
 
 def iter_mm_outputs(outputs: list[Any]):
     for omni_out in outputs:
-        req_out = getattr(omni_out, "request_output", None)
+        req_out = omni_out
         req_list = req_out if isinstance(req_out, list) else [req_out]
         for item in req_list:
             if item is None:

examples/offline_inference/hunyuan_image3/end2end.py

@@ -303,7 +303,7 @@ def main():
     )
     img_idx = 0
     for req_output in omni_outputs:
-        ro = getattr(req_output, "request_output", None)
+        ro = req_output
         stage_id = getattr(req_output, "stage_id", None)
 
         # AR stage text — each CompletionOutput.text is already a delta when

examples/offline_inference/image_to_image/image_edit.py

@@ -621,7 +621,7 @@ def main():
         images = getattr(output, "images", None)
         if images:
             break
-        req_out = getattr(output, "request_output", None)
+        req_out = output
         images = getattr(req_out, "images", None) if req_out is not None else None
         if images:
             break

examples/offline_inference/image_to_video/image_to_video.py

@@ -60,8 +60,12 @@ from vllm_omni.diffusion.data import DiffusionParallelConfig
 from vllm_omni.diffusion.utils.param_utils import apply_declared_extra_args
 from vllm_omni.entrypoints.omni import Omni
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+from vllm_omni.lora.request import LoRARequest
+from vllm_omni.lora.utils import stable_lora_int_id
+from vllm_omni.model_extras import (
+    build_image_to_video_prompt as build_model_image_to_video_prompt,
+)
 from vllm_omni.model_extras import (
-    build_image_to_video_prompt,
     get_extra_body_params,
     get_model_class_name,
 )
@@ -83,6 +87,22 @@ def parse_json_object(value: str, flag_name: str = "argument") -> dict[str, Any]
 parse_profiler_config = functools.partial(parse_json_object, flag_name="--profiler-config")
 
 
+def build_image_to_video_prompt(
+    prompt: str,
+    negative_prompt: str | None,
+    media_inputs: dict[str, Any],
+) -> dict[str, Any]:
+    """Build the canonical request envelope for the shared I2V example."""
+    result: dict[str, Any] = {
+        "prompt": prompt,
+        "modalities": ["video"],
+        "multi_modal_data": media_inputs,
+    }
+    if negative_prompt is not None:
+        result["negative_prompt"] = negative_prompt
+    return result
+
+
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(
         description=(
@@ -294,6 +314,30 @@ def parse_args() -> argparse.Namespace:
         default=None,
         help='JSON profiler config for torch/cuda profiling, e.g. \'{"profiler":"torch","torch_profiler_dir":"./perf"}\'.',
     )
+    parser.add_argument(
+        "--lora-path",
+        type=str,
+        nargs="+",
+        default=None,
+        help="Path to a LoRA adapter folder (PEFT format) or concrete LoRA checkpoint files. "
+        "For Wan2.2 MoE models, pass the high-noise checkpoint first and the low-noise checkpoint second.",
+    )
+    parser.add_argument(
+        "--lora-scale",
+        type=float,
+        default=1.0,
+        help="Scale factor for PEFT LoRA weights (default: 1.0).",
+    )
+    parser.add_argument(
+        "--lora-backend",
+        type=str,
+        default="peft",
+        choices=["peft", "distill"],
+        help=(
+            "LoRA backend. 'peft' loads a PEFT-format adapter for request-time activation; "
+            "'distill' fuses one or more concrete LoRA checkpoint files at initialization."
+        ),
+    )
     parser.add_argument(
         "--extra-body",
         type=functools.partial(parse_json_object, flag_name="--extra-body"),
@@ -487,6 +531,12 @@ def main():
         omni_kwargs["flow_shift"] = flow_shift
     if args.quantization is not None:
         omni_kwargs["quantization"] = args.quantization
+    if args.lora_path is not None:
+        lora_path = args.lora_path
+        if len(lora_path) == 1:
+            lora_path = lora_path[0]
+        omni_kwargs["lora_path"] = lora_path
+        omni_kwargs["lora_backend"] = args.lora_backend
     # Cosmos3 loads its (gated) guardrail models at build time, so the guardrails
     # gate is an engine-level config (offline analog of the server's --no-guardrails).
     if args.extra_body and "guardrails" in args.extra_body:
@@ -517,19 +567,39 @@ def main():
     print(f"  Video size: {width}x{height}")
     print(f"{'=' * 60}\n")
 
+    lora_request = None
+    if args.lora_path and args.lora_backend == "peft":
+        if len(args.lora_path) != 1:
+            raise ValueError("Only one LoRA path is expected for PEFT backend.")
+
+        lora_path = args.lora_path[0]
+        lora_request = LoRARequest(
+            lora_name=Path(lora_path).stem,
+            lora_int_id=stable_lora_int_id(lora_path),
+            lora_path=lora_path,
+        )
+
     negative_prompt = args.negative_prompt
     if negative_prompt is None and not is_ltx2:
         # Preserve the historical empty-prompt behavior for non-LTX examples.
         negative_prompt = ""
     prompt_dict = build_image_to_video_prompt(
-        model_class_name=model_class_name,
         prompt=args.prompt,
         negative_prompt=negative_prompt,
         media_inputs=media_inputs,
+    )
+    prompt_dict = build_model_image_to_video_prompt(
+        model_class_name=model_class_name,
+        prompt=prompt_dict,
         height=height,
         width=width,
         num_frames=num_frames,
     )
+    sampling_extra_args = {"sample_solver": args.sample_solver}
+    if lora_request is not None:
+        sampling_extra_args["lora_request"] = lora_request
+        sampling_extra_args["lora_scale"] = args.lora_scale
+
     sampling_params = OmniDiffusionSamplingParams(
         height=height,
         width=width,
@@ -540,7 +610,7 @@ def main():
         num_inference_steps=num_inference_steps,
         num_frames=num_frames,
         frame_rate=frame_rate,
-        extra_args={"sample_solver": args.sample_solver},
+        extra_args=sampling_extra_args,
     )
     if flow_shift is not None:
         sampling_params.extra_args["flow_shift"] = flow_shift
@@ -576,8 +646,8 @@ def main():
         if frames.multimodal_output and "audio" in frames.multimodal_output:
             audio = frames.multimodal_output["audio"]
             audio_sample_rate = frames.multimodal_output.get("audio_sample_rate", audio_sample_rate)
-        if frames.is_pipeline_output and frames.request_output is not None:
-            inner_output = frames.request_output
+        if frames.is_pipeline_output and frames is not None:
+            inner_output = frames
             if isinstance(inner_output, OmniRequestOutput):
                 if inner_output.multimodal_output and "audio" in inner_output.multimodal_output:
                     audio = inner_output.multimodal_output["audio"]

examples/offline_inference/mammothmodal2_preview/run_mammothmoda2_image_summarize.py

@@ -0,0 +1,117 @@
+"""
+Offline inference example: MammothModa2 image summarization (single AR stage).
+
+Example:
+  uv run python examples/offline_inference/mammothmodal2_preview/run_mammothmoda2_image_summarize.py \
+    --model path/to/MammothModa2-Preview \
+    --deploy-config vllm_omni/deploy/mammoth_moda2_ar.yaml \
+    --image /path/to/input.jpg \
+    --question "Please summarize the content of this image."
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+
+from PIL import Image
+from vllm import SamplingParams
+from vllm.multimodal.image import convert_image_mode
+
+from vllm_omni import Omni
+
+DEFAULT_SYSTEM = "You are a helpful assistant."
+DEFAULT_QUESTION = "Please summarize the content of this image."
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="MammothModa2 image summarization (offline, AR only).")
+    parser.add_argument("--model", type=str, required=True, help="Path to model directory or model id.")
+    parser.add_argument("--deploy-config", type=str, required=True, help="Path to deploy config yaml.")
+    parser.add_argument("--image", type=str, required=True, help="Path to input image.")
+    parser.add_argument("--question", type=str, default=DEFAULT_QUESTION, help="Question/instruction for the model.")
+    parser.add_argument("--system", type=str, default=DEFAULT_SYSTEM, help="System prompt.")
+    parser.add_argument(
+        "--max-tokens",
+        type=int,
+        default=512,
+        help="Max new tokens to generate.",
+    )
+    parser.add_argument("--temperature", type=float, default=0.2)
+    parser.add_argument("--top-p", type=float, default=0.9)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--trust-remote-code", action="store_true")
+    parser.add_argument(
+        "--enable-diffusion-pipeline-profiler",
+        action="store_true",
+        help="Enable diffusion pipeline profiler to display stage durations.",
+    )
+    return parser.parse_args()
+
+
+def build_prompt(system: str, question: str) -> str:
+    return (
+        f"<|im_start|>system\n{system}<|im_end|>\n"
+        "<|im_start|>user\n"
+        "<|vision_start|><|image_pad|><|vision_end|>"
+        f"{question}<|im_end|>\n"
+        "<|im_start|>assistant\n"
+    )
+
+
+def main() -> None:
+    args = parse_args()
+
+    if not os.path.exists(args.image):
+        raise FileNotFoundError(f"Image file not found: {args.image}")
+
+    pil_image = Image.open(args.image)
+    image_data = convert_image_mode(pil_image, "RGB")
+    prompt = build_prompt(args.system, args.question)
+
+    omni = Omni(
+        model=args.model,
+        deploy_config=args.deploy_config,
+        trust_remote_code=args.trust_remote_code,
+        enable_diffusion_pipeline_profiler=args.enable_diffusion_pipeline_profiler,
+    )
+    try:
+        sp = SamplingParams(
+            temperature=float(args.temperature),
+            top_p=float(args.top_p),
+            top_k=-1,
+            max_tokens=int(args.max_tokens),
+            seed=int(args.seed),
+            detokenize=True,
+        )
+        # NOTE: omni.generate() returns a Generator[OmniRequestOutput, None, None].
+        # Consume it inside the try block so the worker isn't closed early.
+        outputs = list(
+            omni.generate(
+                [
+                    {
+                        "prompt": prompt,
+                        "multi_modal_data": {"image": image_data},
+                        "additional_information": {"omni_task": ["chat"]},
+                    }
+                ],
+                [sp],
+            )
+        )
+    finally:
+        omni.close()
+
+    lines: list[str] = []
+    for stage_outputs in outputs:
+        ro = stage_outputs
+        text = ro.outputs[0].text if getattr(ro, "outputs", None) else str(ro)
+        lines.append(f"request_id: {getattr(ro, 'request_id', 'unknown')}\n")
+        lines.append("answer:\n")
+        lines.append(text.strip() + "\n")
+        lines.append("\n")
+
+    print("\n".join(lines))
+
+
+if __name__ == "__main__":
+    main()

examples/offline_inference/mimo_audio/end2end.py

@@ -297,7 +297,7 @@ def main(args):
     os.makedirs(output_dir, exist_ok=True)
 
     for stage_outputs in omni_outputs:
-        output = stage_outputs.request_output
+        output = stage_outputs
         if stage_outputs.final_output_type == "text":
             request_id = output.request_id
             text_output = output.outputs[0].text

examples/offline_inference/ming_flash_omni/end2end.py

@@ -347,7 +347,7 @@ def main(args):
         omni.start_profile(stages=args.profiler_stages)
 
     for stage_outputs in omni.generate(prompts, sampling_params_list):
-        output = stage_outputs.request_output
+        output = stage_outputs
         if stage_outputs.final_output_type == "text":
             request_id = output.request_id
             text_output = output.outputs[0].text

examples/offline_inference/nemotron_voicechat/end2end.py

@@ -0,0 +1,229 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Offline speech-to-speech with NVIDIA-NemotronLabs-VoiceChat-11B.
+
+Feeds a 16 kHz user utterance (plus a spoken-style system prompt) through the
+3-stage nemotron_voicechat pipeline and writes the agent's reply as text and a
+22.05 kHz WAV.
+
+Usage:
+    python end2end.py \
+        --checkpoint /path/to/NVIDIA-NemotronLabs-VoiceChat-11B \
+        --wav /path/to/user_question_16k.wav \
+        --output-dir results/nemotron_voicechat
+
+The system prompt defaults to the NeMo reference default. The text tokenizer
+resolves from the ``nvidia/NVIDIA-Nemotron-Nano-9B-v2`` HF id (or the
+``NEMOTRON_VOICECHAT_LLM_PATH`` env var for air-gapped runs).
+
+Sizing the input WAV: the timeline is frame-locked, so the reply budget IS the
+input duration — the acoustic channel trails the text channel, and a reply
+that has not finished when the frames run out is truncated SILENTLY (no error;
+ASR of the WAV will just disagree with the emitted text). Leave generous
+trailing silence after the question (a question ending at ~4.5 s truncated in
+an 8 s WAV but completed cleanly in a 16 s one). The script warns when the
+text channel is still emitting non-PAD tokens near the last frame.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+
+import numpy as np
+import soundfile as sf
+
+# Warn if the text channel is still speaking within this many final frames
+# (12 frames = ~1 s) — the frame-locked reply likely got cut off.
+TRUNCATION_GUARD_FRAMES = 12
+
+# The NeMo reference offline script's default system prompt.
+DEFAULT_SYSTEM_PROMPT = (
+    "You are an AI voice assistant developed by NVIDIA. "
+    "Your name is NVIDIA Voice Chat. "
+    "Answer in a spoken, conversational style rather than a written one. "
+    "Do not repeat the same sentence over and over again. "
+    "Start the conversation by greeting the user."
+)
+
+
+def load_wav_16k_mono(path: str) -> np.ndarray:
+    wav, sr = sf.read(path, dtype="float32")
+    if wav.ndim > 1:
+        wav = wav.mean(axis=1)
+    if sr != 16000:
+        from vllm.multimodal.audio import resample_audio_scipy
+
+        wav = resample_audio_scipy(wav, orig_sr=sr, target_sr=16000)
+    return wav.astype(np.float32)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--checkpoint", required=True, help="NVIDIA-NemotronLabs-VoiceChat-11B directory")
+    parser.add_argument("--wav", required=True, help="user speech (any sr; resampled to 16 kHz mono)")
+    parser.add_argument("--output-dir", default="results/nemotron_voicechat")
+    parser.add_argument("--system-prompt", default=DEFAULT_SYSTEM_PROMPT)
+    parser.add_argument(
+        "--stage-configs-path",
+        default=None,
+        help=(
+            "Deploy yaml override. Pass vllm_omni/deploy/nemotron_labs_voicechat_streaming.yaml "
+            "for the async-chunk streaming pipeline (stages overlap; audio starts decoding "
+            "before the thinker finishes). Default: the bundled non-streaming yaml (bit-exact "
+            "parity path)."
+        ),
+    )
+    args = parser.parse_args()
+
+    if not Path(args.wav).is_file():
+        raise FileNotFoundError(f"Input WAV not found: {args.wav}")
+    ckpt = Path(args.checkpoint)
+    raw_cfg = json.loads((ckpt / "config.json").read_text())
+    stt_cfg = raw_cfg["model"]["stt"]["model"]
+
+    from transformers import AutoTokenizer
+    from vllm.sampling_params import SamplingParams
+
+    from vllm_omni.entrypoints.omni import Omni
+    from vllm_omni.model_executor.models.nemotron_voicechat.nemotron_voicechat_thinker import (
+        compute_acoustic_frame_count,
+    )
+
+    tok_ref = os.environ.get("NEMOTRON_VOICECHAT_LLM_PATH") or stt_cfg.get(
+        "pretrained_llm", "nvidia/NVIDIA-Nemotron-Nano-9B-v2"
+    )
+    tokenizer = AutoTokenizer.from_pretrained(tok_ref, trust_remote_code=False)
+    bos_id = tokenizer.convert_tokens_to_ids(stt_cfg.get("bos_token", "<s>"))
+    eos_id = tokenizer.convert_tokens_to_ids(stt_cfg.get("eos_token", "</s>"))
+    pad_id = tokenizer.convert_tokens_to_ids(stt_cfg.get("pad_token", "<SPECIAL_12>"))
+    # NeMo encode_system_prompt: [bos] + tokens + [eos].
+    prompt_ids = [bos_id] + tokenizer.encode(args.system_prompt, add_special_tokens=False) + [eos_id]
+
+    wav = load_wav_16k_mono(args.wav)
+    n_frames = compute_acoustic_frame_count(stt_cfg, int(wav.shape[0]))
+    print(f"input: {wav.shape[0]} samples @16kHz -> {n_frames} acoustic frames; prompt {len(prompt_ids)} tokens")
+
+    inputs = {
+        # vLLM prompt = system prompt + one placeholder position (acoustic
+        # frame 0); the thinker replaces every position with fused embeddings.
+        "prompt_token_ids": prompt_ids + [pad_id],
+        "additional_information": {
+            # Plain float list: raw ndarrays do not survive the engine-core
+            # message serialization.
+            "nvc_audio": wav.astype(np.float32).tolist(),
+            "nvc_sr": 16000,
+            "nvc_prompt_token_ids": prompt_ids,
+            "nvc_expected_frames": n_frames,
+        },
+    }
+    sampling_params_list = [
+        # thinker: greedy, frame-locked generation length. NO min_tokens: the
+        # tokenizer's eos_token is <SPECIAL_12> — the frame-locked PAD/silence
+        # token — and vLLM's min_tokens masks "EOS" to -inf, which would forbid
+        # silence and force the agent to babble through the whole utterance.
+        SamplingParams(temperature=0.0, max_tokens=n_frames, ignore_eos=True, seed=0),
+        # talker: placeholder loop, stops on the stage's stop token. 16383:
+        # the 1-token placeholder prompt + max_tokens must fit the stage's
+        # max_model_len (16384).
+        SamplingParams(temperature=0.0, max_tokens=16383, stop_token_ids=[1], detokenize=False, seed=0),
+        # code2wav: single decode step.
+        SamplingParams(temperature=0.0, max_tokens=1, detokenize=False, seed=0),
+    ]
+
+    omni_kwargs: dict = {}
+    if args.stage_configs_path:
+        omni_kwargs["stage_configs_path"] = args.stage_configs_path
+    omni = Omni(model=str(ckpt), trust_remote_code=True, **omni_kwargs)
+    outputs = omni.generate(inputs, sampling_params_list)
+
+    out_dir = Path(args.output_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    stem = Path(args.wav).stem
+
+    agent_text = None
+    audio = None
+    sr = 22050
+    for stage_outputs in outputs:
+        # One entry per final stage (text from the thinker, audio from code2wav);
+        # mirrors the qwen2_5_omni offline example's collection loop.
+        output = getattr(stage_outputs, "request_output", stage_outputs)
+        final_type = getattr(stage_outputs, "final_output_type", None)
+        completions = getattr(output, "outputs", None) or []
+        if not completions:
+            continue
+        completion = completions[0]
+        if final_type in (None, "text"):
+            text = getattr(completion, "text", None)
+            if text:
+                agent_text = text
+            token_ids = getattr(completion, "token_ids", None)
+            if token_ids:
+                (out_dir / f"{stem}_text_tokens.json").write_text(json.dumps(list(map(int, token_ids))))
+                # Frame lock: the reply budget IS the input length. If the text
+                # channel is still mid-sentence when the frames run out, the
+                # spoken answer is silently truncated — warn instead.
+                tail = list(map(int, token_ids))[-TRUNCATION_GUARD_FRAMES:]
+                if any(t != pad_id for t in tail):
+                    print(
+                        f"WARNING: the text channel emits non-PAD tokens within the last "
+                        f"{TRUNCATION_GUARD_FRAMES} frames ({TRUNCATION_GUARD_FRAMES * 80} ms) — the reply "
+                        "likely ran out of acoustic frames and is cut off mid-sentence. "
+                        "Pad the input WAV with more trailing silence and rerun."
+                    )
+            # Best-effort: dump the function-channel debug timeline if the
+            # engine surfaced the request info on this output.
+            info = getattr(output, "additional_information", None)
+            func_timeline = info.get("nvc_function_tokens") if isinstance(info, dict) else None
+            if func_timeline is not None:
+                values = func_timeline.tolist() if hasattr(func_timeline, "tolist") else list(func_timeline)
+                (out_dir / f"{stem}_function_tokens.json").write_text(json.dumps([int(v) for v in values]))
+                print(f"function-channel timeline: {len(values)} entries")
+        if final_type in (None, "audio"):
+            # multimodal_output is a MultimodalPayload (Mapping) — duck-type it.
+            mm = getattr(completion, "multimodal_output", None)
+            get = getattr(mm, "get", None)
+            if not callable(get):
+                continue
+            candidate = None
+            for key in ("audio", "model_outputs", "wav", "waveform"):
+                value = get(key)
+                if value is not None:
+                    candidate = value
+                    break
+            if isinstance(candidate, list):
+                candidate = candidate[0] if candidate else None
+            if candidate is not None:
+                arr = np.asarray(
+                    candidate.float().cpu() if hasattr(candidate, "cpu") else candidate, dtype=np.float32
+                ).reshape(-1)
+                if arr.size > 0:
+                    audio = arr
+                sr_val = get("sr")
+                if sr_val is not None:
+                    sr_item = sr_val[0] if isinstance(sr_val, list) else sr_val
+                    sr = int(sr_item.item() if hasattr(sr_item, "item") else sr_item)
+
+    if agent_text is not None:
+        # The frame-locked text channel emits PAD tokens on silent frames;
+        # strip them (NeMo's post-inference detokenizer does the same).
+        pad_token = stt_cfg.get("pad_token", "<SPECIAL_12>")
+        agent_text = " ".join(agent_text.replace(pad_token, " ").split())
+        text_path = out_dir / f"{stem}_output.txt"
+        text_path.write_text(agent_text + "\n")
+        print(f"agent text -> {text_path}\n{agent_text}")
+    else:
+        print("WARNING: no agent text in outputs")
+
+    if audio is not None and audio.size > 0:
+        wav_path = out_dir / f"{stem}_output.wav"
+        sf.write(wav_path, audio, sr)
+        print(f"agent audio -> {wav_path} ({audio.size / sr:.2f}s @ {sr} Hz)")
+    else:
+        raise RuntimeError("No audio produced by the code2wav stage.")
+
+
+if __name__ == "__main__":
+    main()

examples/offline_inference/qwen2_5_omni/end2end.py

@@ -392,7 +392,7 @@ def main(args):
     total_requests = len(prompts)
     processed_count = 0
     for stage_outputs in omni_generator:
-        output = stage_outputs.request_output
+        output = stage_outputs
         if stage_outputs.final_output_type == "text":
             request_id = output.request_id
             text_output = output.outputs[0].text

examples/offline_inference/qwen3_omni/end2end.py

@@ -367,7 +367,7 @@ def main(args):
     print(f"query type: {args.query_type}")
 
     for stage_outputs in omni_generator:
-        output = stage_outputs.request_output
+        output = stage_outputs
         if stage_outputs.final_output_type == "text":
             request_id = output.request_id
             text_output = output.outputs[0].text

examples/offline_inference/qwen3_omni/end2end_async_chunk.py

@@ -237,7 +237,7 @@ async def run_single_request(
             sampling_params_list=sampling_params_list,
             output_modalities=output_modalities,
         ):
-            output = omni_output.request_output
+            output = omni_output
             if omni_output.final_output_type == "text":
                 if stage_0_first_output_ts is None:
                     stage_0_first_output_ts = time.perf_counter()

examples/offline_inference/speech_to_video/speech_to_video.py

@@ -26,7 +26,6 @@ import torch
 from vllm_omni.diffusion.data import DiffusionParallelConfig
 from vllm_omni.entrypoints.omni import Omni
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
-from vllm_omni.outputs import OmniRequestOutput
 from vllm_omni.platforms import current_omni_platform
 
 
@@ -352,8 +351,8 @@ def main():
         else:
             print("[Profiler] No valid profiling data returned.")
 
-    # Extract output from result
-    output = OmniRequestOutput.unwrap_result(result)
+    # omni.generate() returns a list for sync calls; unwrap single-result list.
+    output = result[0] if isinstance(result, list) else result
 
     if not output.images:
         raise ValueError("No video frames found in OmniRequestOutput.")

examples/offline_inference/step_audio2/end2end.py

@@ -345,7 +345,7 @@ def main(args):
     # Process outputs from each stage
     for stage_idx, stage_outputs in enumerate(omni_outputs):
         # request_output may be a single object or a list
-        raw_output = stage_outputs.request_output
+        raw_output = stage_outputs
         outputs_list = raw_output if isinstance(raw_output, list) else [raw_output]
 
         if stage_outputs.final_output_type == "text":

examples/offline_inference/text_to_audio/text_to_audio.py

@@ -43,6 +43,7 @@ from vllm_omni.diffusion.utils.param_utils import apply_declared_extra_args
 from vllm_omni.entrypoints.omni import Omni
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 from vllm_omni.model_extras import get_extra_body_params, get_model_class_name
+from vllm_omni.outputs import OmniRequestOutput
 from vllm_omni.platforms import current_omni_platform
 
 AUDIOX_TASKS = ("t2a", "t2m", "v2a", "v2m", "tv2a", "tv2m")
@@ -388,9 +389,9 @@ def main():
         raise ValueError("No output generated from omni.generate()")
 
     output = outputs[0]
-    if not hasattr(output, "request_output") or not output.request_output:
+    if not isinstance(output, OmniRequestOutput) or not output:
         raise ValueError("No request_output found in OmniRequestOutput")
-    request_output = output.request_output
+    request_output = output
     if not hasattr(request_output, "multimodal_output"):
         raise ValueError("No multimodal_output found in request_output")
 

examples/offline_inference/text_to_image/README.md

@@ -57,8 +57,9 @@ python examples/offline_inference/text_to_image/text_to_image.py \
   --output lingbot_t2i.png
 ```
 
-The LingBot prompt builder selects the `image` output modality and requests one
-frame. Passing an input image is not supported in LingBot T2I mode.
+The shared T2I entry point selects the `image` output modality. The LingBot
+pipeline validates that T2I requests produce one frame and do not include an
+input image.
 
 ## Quick Start
 
@@ -109,8 +110,9 @@ python text_to_image.py \
 | `--ring-degree` | int | `1` | Ring sequence parallel degree for hybrid Ulysses + Ring inference |
 | `--ulysses-mode` | str | `"strict"` | Ulysses SP mode: `"strict"` or `"advanced_uaa"` |
 | `--enable-cpu-offload` | flag | off | Enable CPU offloading for diffusion models |
-| `--lora-path` | str | — | Path to PEFT LoRA adapter folder |
+| `--lora-path` | str | — | Path to PEFT LoRA adapter folder or checkpoint file |
 | `--lora-scale` | float | `1.0` | Scale factor for LoRA weights |
+| `--lora-backend` | str |`"peft"`| LoRA backend for loading LoRA adapters. Default: peft. Available options: peft, distill |
 | `--use-system-prompt` | str | `None` | System prompt preset: `en_unified`, `en_vanilla`, `en_recaption`, `en_think_recaption`, `dynamic`, `None`, or custom text. Recommended: `en_unified`. Only for HunyuanImage-3.0.|
 | `--system-prompt` | str | `None` | Custom system prompt text. Only used when `--use-system-prompt` is set to `custom`. Only for HunyuanImage-3.0.|
 | `--auxiliary-text-encoder` | str | `None` | Supplementary auxiliary text encoder parameters model name or path (especially for Hidream-l1-full). |

examples/offline_inference/text_to_image/gradio_demo.py

@@ -115,7 +115,7 @@ def build_demo(args: argparse.Namespace) -> gr.Blocks:
         )
         images_outputs = []
         for output in outputs:
-            req_out = output.request_output
+            req_out = output
             if not isinstance(req_out, OmniRequestOutput) or not hasattr(req_out, "images"):
                 raise ValueError("Invalid request_output structure or missing 'images' key")
             images = req_out.images

examples/offline_inference/text_to_image/text_to_image.py

@@ -21,7 +21,9 @@ from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 from vllm_omni.lora.request import LoRARequest
 from vllm_omni.lora.utils import stable_lora_int_id
 from vllm_omni.model_extras import (
-    build_text_to_image_prompt,
+    build_text_to_image_prompt as build_model_text_to_image_prompt,
+)
+from vllm_omni.model_extras import (
     get_extra_body_params,
     get_model_class_name,
     should_init_extra_args_for_non_diffusion_stages,
@@ -56,6 +58,17 @@ def parse_json_object(value: str, flag_name: str = "argument") -> dict[str, Any]
 parse_profiler_config = functools.partial(parse_json_object, flag_name="--profiler-config")
 
 
+def build_text_to_image_prompt(prompt: str, negative_prompt: str | None) -> dict[str, Any]:
+    """Build the canonical request envelope for the shared T2I example."""
+    result: dict[str, Any] = {
+        "prompt": prompt,
+        "modalities": ["image"],
+    }
+    if negative_prompt is not None:
+        result["negative_prompt"] = negative_prompt
+    return result
+
+
 def _normalize_images_for_save(images: list[Any]) -> list[Any]:
     """Convert NumPy diffusion outputs to PIL images before saving."""
     normalized = []
@@ -260,6 +273,7 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument(
         "--lora-path",
         type=str,
+        nargs="+",
         default=None,
         help="Path to LoRA adapter folder (PEFT format). Loaded at initialization and used for generation.",
     )
@@ -269,6 +283,15 @@ def parse_args() -> argparse.Namespace:
         default=1.0,
         help="Scale factor for LoRA weights (default: 1.0).",
     )
+    parser.add_argument(
+        "--lora-backend",
+        type=str,
+        default="peft",
+        choices=["peft", "distill"],
+        help="LoRA backend for loading LoRA adapters. Default: peft"
+        "'peft' loads a PEFT-format adapter folder, used e.g. for RL"
+        "'distill' fuses one or more concrete LoRA checkpoint files, used e.g. for distilled few-step LoRAs",
+    )
     parser.add_argument(
         "--vae-patch-parallel-size",
         type=int,
@@ -404,8 +427,12 @@ def main():
     # Prepare LoRA kwargs for Omni initialization
     lora_args: dict[str, Any] = {}
     if args.lora_path:
-        lora_args["lora_path"] = args.lora_path
-        print(f"Using LoRA from: {args.lora_path}")
+        lora_path = args.lora_path
+        if len(lora_path) == 1:
+            lora_path = lora_path[0]
+        lora_args["lora_path"] = lora_path
+        lora_args["lora_backend"] = args.lora_backend
+        print(f"Using LoRA from: {lora_path} with backend: {args.lora_backend}")
 
     # Build quantization kwargs: use quantization_config dict when
     # ignored_layers is specified so the list flows through OmniDiffusionConfig
@@ -494,20 +521,27 @@ def main():
 
     # Build LoRA request when --lora-path is set
     lora_request = None
-    if args.lora_path:
-        lora_request_id = stable_lora_int_id(args.lora_path)
+    if args.lora_path and args.lora_backend == "peft":
+        if len(args.lora_path) != 1:
+            raise ValueError("Only one LoRA path is expected for PEFT backend.")
+
+        lora_path = args.lora_path[0]
+        lora_request_id = stable_lora_int_id(lora_path)
         lora_request = LoRARequest(
-            lora_name=Path(args.lora_path).stem,
+            lora_name=Path(lora_path).stem,
             lora_int_id=lora_request_id,
-            lora_path=args.lora_path,
+            lora_path=lora_path,
         )
 
     generation_start = time.perf_counter()
 
     prompt_dict = build_text_to_image_prompt(
-        model_class_name=model_class_name,
         prompt=args.prompt,
         negative_prompt=args.negative_prompt,
+    )
+    prompt_dict = build_model_text_to_image_prompt(
+        model_class_name=model_class_name,
+        prompt=prompt_dict,
         height=args.height,
         width=args.width,
     )
@@ -622,7 +656,7 @@ def main():
         images = getattr(output, "images", None)
         if images:
             break
-        req_out = getattr(output, "request_output", None)
+        req_out = output
         images = getattr(req_out, "images", None) if req_out is not None else None
         if images:
             break

examples/offline_inference/text_to_speech/README.md

@@ -24,6 +24,7 @@ list of supported architectures across all modalities, see
 | Qwen3-TTS | `Qwen/Qwen3-TTS-12Hz-1.7B-{CustomVoice,VoiceDesign,Base}` | 2 (talker + code2wav) | ✓ (Base) | ✓ | 3 task variants | 24 kHz |
 | VoxCPM2 | `openbmb/VoxCPM2` | single (native AR) | ✓ | ✓ (online) | continuation | 48 kHz |
 | IndexTTS-2 | `IndexTeam/IndexTTS-2` | 2 (AR talker + S2Mel DiT + BigVGAN) | ✓ (required) | — | emotion control (`--emo-audio`, `--emo-text`, `--emo-vector`) | 22.05 kHz |
+| IndexTTS-2.5 | native `checkpoints/` bundle | 2 (AR talker + EnhancedCodec + S2Mel DiT + BigVGAN) | ✓ (required) | — | multilingual (`--lang`) + emotion control | 22.05 kHz |
 | Voxtral TTS | `mistralai/Voxtral-4B-TTS-2603` | varies | ✓ | ✓ | voice presets | 24 kHz |
 
 ## Common Quick Start
@@ -371,18 +372,10 @@ python examples/offline_inference/text_to_speech/qwen3_tts/end2end.py \
 Streaming requires `async_chunk: true` in the stage config.
 
 ### Word Timestamps
-Generate a WAV offline and a JSON sidecar with word-level timestamps from
-`Qwen/Qwen3-ForcedAligner-0.6B`:
-```bash
-python examples/offline_inference/text_to_speech/qwen3_tts/word_timestamps.py \
-    --model Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice \
-    --forced-aligner Qwen/Qwen3-ForcedAligner-0.6B \
-    --text "Hello world." \
-    --output-dir /tmp/qwen3_tts_timestamps
-```
-The script writes `qwen3_tts_word_timestamps.wav` and
-`qwen3_tts_word_timestamps.json`. On machines without a local CUDA toolkit,
-set `VLLM_USE_FLASHINFER_SAMPLER=0` to avoid FlashInfer sampler JIT.
+Word-level timestamps are currently a serving-path feature: launch
+`vllm-omni serve` with `--forced-aligner` and request `word_timestamps`
+(see `examples/online_serving/text_to_speech/README.md`). An offline
+example is not provided in this release.
 
 ### Batched decoding
 The Code2Wav stage supports batched decoding through the SpeechTokenizer. Pass multiple prompts via `--txt-prompts` and set `--batch-size` accordingly. To raise `max_num_seqs` on either stage, point `--stage-configs-path` at a stage configs YAML with the desired values (see `vllm_omni/model_executor/stage_configs/` for templates):
@@ -437,11 +430,14 @@ Streaming is exposed through the online OpenAI Speech API (`stream=true`). See [
 
 ---
 
-## IndexTTS-2
+## IndexTTS-2 and IndexTTS-2.5
 
-2-stage TTS pipeline (GPT AR talker + S2Mel CFM DiT + BigVGAN vocoder) at 22.05 kHz. Every request requires reference audio for zero-shot voice cloning. Supports emotion conditioning via audio, text, or 8-dim vector.
+Both versions use a 2-stage TTS pipeline and produce 22.05 kHz mono audio. Stage 0 is a GPT AR talker. IndexTTS-2 Stage 1 uses RepCodec semantic embeddings, GPT latent, S2Mel CFM/DiT, and BigVGAN. IndexTTS-2.5 replaces RepCodec with EnhancedCodec and uses the official code-only path (`use_gpt_latent=false`). Every request requires reference audio for zero-shot voice cloning.
 
 ### Quick start
+
+IndexTTS-2:
+
 ```bash
 python examples/offline_inference/text_to_speech/indextts2/end2end.py \
     --model IndexTeam/IndexTTS-2 \
@@ -449,6 +445,24 @@ python examples/offline_inference/text_to_speech/indextts2/end2end.py \
     --ref-audio /path/to/reference.wav
 ```
 
+IndexTTS-2 uses its existing frontend and does not require the IndexTTS-2.5 text dependencies. Before running IndexTTS-2.5, install its optional frontend dependencies:
+
+```bash
+pip install 'vllm-omni[indextts2]'
+```
+
+IndexTTS-2.5 with a native repository/lab bundle whose model root contains `checkpoints/`:
+
+```bash
+python examples/offline_inference/text_to_speech/indextts2/end2end.py \
+    --model /path/to/indextts-2.5 \
+    --model-version 2.5 \
+    --lang ja \
+    --text "こんにちは、音声合成のテストです。" \
+    --ref-audio /path/to/reference.wav
+
+```
+
 ### Emotion control
 ```bash
 # Emotion from reference audio
@@ -474,10 +488,13 @@ python examples/offline_inference/text_to_speech/indextts2/end2end.py \
 ```
 
 ### Notes
-- `--ref-audio` is **required** — IndexTTS-2 does not support text-only synthesis.
-- Stage 0 (AR Talker): GPT-2 generates mel codes from text + reference audio.
-- Stage 1 (S2Mel + BigVGAN): CFM DiT converts mel codes to waveform at 22.05 kHz.
-- Deploy config: `vllm_omni/deploy/indextts2.yaml`. Stage 1 runs with `enforce_eager: true` (DiT has dynamic shapes).
+- `--ref-audio` is **required** — neither version provides text-only synthesis.
+- IndexTTS-2.5 Stage 0 (AR Talker) generates mel codes from text + reference audio using plain vLLM sampling. It does not reproduce the official default `num_beams=3` beam search. For parity comparisons, run upstream with `num_beams=1`; output quality can differ from the official beam-search result.
+- IndexTTS-2.5 accepts language codes such as `zh`, `en`, `zhen` (mixed Chinese/English), `ja`, and `yue`. `Mandarin` is a vLLM-Omni convenience alias for `zh`. Japanese (`ja`) uses `fugashi` tokenization and produces audio, but it does not automatically expand numbers, dates, or percentages; write those inputs as readable Japanese text before calling the model. Use `--no-text-normalization` only when the input is already normalized.
+- A seed controls Stage 0 AR sampling and per-request CFM noise. Different concurrent batch compositions do not guarantee a bit-identical waveform.
+- Stage 1 (semantic codec + S2Mel + BigVGAN): CFM/DiT converts the complete semantic-code sequence to waveform.
+- Deploy configs: `vllm_omni/deploy/indextts2.yaml` and `indextts2_5.yaml`.
+- `async_chunk=false` is intentional for IndexTTS-2.5 correctness: S2Mel consumes the completed semantic sequence.
 
 ---
 

examples/offline_inference/text_to_speech/cosyvoice3/end2end.py

@@ -168,7 +168,7 @@ def run_e2e():
     print(f"Received {len(outputs)} outputs.")
     for i, output in enumerate(outputs):
         try:
-            ro = output.request_output
+            ro = output
             if ro is None:
                 print("No request_output found.")
                 continue

examples/offline_inference/text_to_speech/fish_speech/end2end.py

@@ -179,7 +179,7 @@ def main(args):
 
     t_start = time.perf_counter()
     for stage_outputs in omni.generate(inputs):
-        request_output = stage_outputs.request_output
+        request_output = stage_outputs
         if request_output is None or not request_output.outputs:
             continue
         _save_wav(
@@ -215,7 +215,7 @@ async def main_streaming(args):
     sample_rate = None
 
     async for stage_output in omni.generate(prompt, request_id=request_id):
-        mm = stage_output.request_output.outputs[0].multimodal_output
+        mm = stage_output.outputs[0].multimodal_output
         if not stage_output.finished:
             t_now = time.perf_counter()
             sample_rate, n = _collect_audio_chunk(mm, all_audio_chunks, sample_rate)

examples/offline_inference/text_to_speech/indextts2/end2end.py

@@ -1,13 +1,16 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-"""Offline inference example for IndexTTS2 via vLLM-Omni.
+"""Offline inference example for IndexTTS 2.0 and 2.5 via vLLM-Omni.
 
-Two-stage pipeline: GPT AR (Stage 0) → S2Mel + BigVGAN (Stage 1).
+Two-stage pipeline: GPT AR (Stage 0) → semantic codec + S2Mel + BigVGAN
+(Stage 1).
 Output is 22050 Hz mono WAV.
 
 Usage:
   python end2end.py \
-    --model /path/to/IndexTeam/IndexTTS-2 \
+    --model /path/to/indextts-2.5 \
+    --model-version 2.5 \
+    --lang zh \
     --text "你好，这是一个语音合成测试。" \
     --ref-audio /path/to/ref.wav
 
@@ -47,6 +50,10 @@ def build_request(
     emo_alpha: float | None = None,
     use_emo_text: bool = False,
     use_random: bool = False,
+    model_type: str = "indextts2",
+    lang: str = "zh",
+    text_normalization: bool = True,
+    tokenizer_file: str | None = None,
 ) -> dict:
     additional: dict = {"text": [text]}
     if ref_audio_path:
@@ -63,12 +70,44 @@ def build_request(
         additional["use_emo_text"] = [True]
     if use_random:
         additional["use_random"] = [True]
+    if model_type == "indextts2_5":
+        additional["lang"] = [lang]
+        additional["text_normalization"] = [text_normalization]
+    prompt_kwargs = {
+        "model_type": model_type,
+        "lang": lang,
+        "text_normalization": text_normalization,
+    }
+    if tokenizer_file is not None:
+        prompt_kwargs["tokenizer_file"] = tokenizer_file
     return {
-        "prompt_token_ids": build_indextts2_prefill_prompt_ids(model, text),
+        "prompt_token_ids": build_indextts2_prefill_prompt_ids(
+            model,
+            text,
+            **prompt_kwargs,
+        ),
         "additional_information": additional,
     }
 
 
+def _get_stage0_tokenizer_file(omni: Omni) -> str | None:
+    """Read the effective tokenizer override from the resolved Stage 0 config."""
+    stage_configs = omni.stage_configs
+    if not stage_configs:
+        return None
+    engine_args = getattr(stage_configs[0], "engine_args", None)
+    if engine_args is None:
+        return None
+    hf_overrides = getattr(engine_args, "hf_overrides", None)
+    if hf_overrides is None and isinstance(engine_args, dict):
+        hf_overrides = engine_args.get("hf_overrides")
+    if hf_overrides is None:
+        return None
+    if hasattr(hf_overrides, "get"):
+        return hf_overrides.get("tokenizer_file")
+    return getattr(hf_overrides, "tokenizer_file", None)
+
+
 def save_audio(waveform: torch.Tensor, path: str, sample_rate: int = 22050) -> None:
     audio_np = waveform.float().numpy()
     sf.write(path, audio_np, sample_rate)
@@ -95,9 +134,14 @@ def extract_audio(mm: dict) -> tuple[torch.Tensor | None, int]:
 
 
 def main(args) -> None:
+    model_type = "indextts2_5" if args.model_version == "2.5" else "indextts2"
+    deploy_config = args.deploy_config
+    if deploy_config is None and args.model_version == "2.5":
+        repo_root = Path(__file__).resolve().parents[4]
+        deploy_config = str(repo_root / "vllm_omni" / "deploy" / "indextts2_5.yaml")
     omni = Omni(
         model=args.model,
-        deploy_config=args.deploy_config,
+        deploy_config=deploy_config,
         stage_init_timeout=args.stage_init_timeout,
     )
 
@@ -126,7 +170,7 @@ def main(args) -> None:
     print(f"Synthesizing: {args.text!r}")
     if args.ref_audio:
         print(f"  ref_audio: {args.ref_audio}")
-    inputs = build_request(
+    request_kwargs = dict(
         model=args.model,
         text=args.text,
         ref_audio_path=args.ref_audio,
@@ -136,7 +180,17 @@ def main(args) -> None:
         emo_alpha=args.emo_alpha,
         use_emo_text=args.use_emo_text,
         use_random=args.use_random,
+        model_type=model_type,
+        lang=args.lang,
+        text_normalization=args.text_normalization,
     )
+    if model_type == "indextts2_5":
+        tokenizer_file = _get_stage0_tokenizer_file(omni)
+        if tokenizer_file is not None:
+            request_kwargs["tokenizer_file"] = tokenizer_file
+    inputs = build_request(**request_kwargs)
+    if model_type == "indextts2_5":
+        inputs["additional_information"]["duration_factor"] = [1.0 / getattr(args, "speed", 1.0)]
 
     for i, omni_out in enumerate(omni.generate(inputs, sampling_params_list=sampling_params)):
         mm = omni_out.multimodal_output
@@ -154,8 +208,37 @@ def main(args) -> None:
 
 
 def parse_args():
-    parser = FlexibleArgumentParser(description="IndexTTS2 offline inference")
-    parser.add_argument("--model", required=True, help="HF model path for IndexTTS2.")
+    parser = FlexibleArgumentParser(description="IndexTTS 2.0/2.5 offline inference")
+    parser.add_argument(
+        "--model",
+        required=True,
+        help="HF model path or native bundle containing checkpoints/.",
+    )
+    parser.add_argument(
+        "--model-version",
+        choices=("2.0", "2.5"),
+        default="2.0",
+    )
+    parser.add_argument(
+        "--lang",
+        default="zh",
+        help=(
+            "IndexTTS 2.5 language code, for example zh/en/zhen/ja/yue; "
+            "zhen is mixed Chinese/English and Mandarin is a vLLM-Omni alias for zh."
+        ),
+    )
+    parser.add_argument(
+        "--no-text-normalization",
+        action="store_false",
+        dest="text_normalization",
+        help="Disable IndexTTS 2.5 text normalization.",
+    )
+    parser.add_argument(
+        "--speed",
+        type=float,
+        default=1.0,
+        help="IndexTTS 2.5 native synthesis speed in [0.5, 2.0]; 2.0 is faster.",
+    )
     parser.add_argument("--text", default="你好，这是IndexTTS2语音合成测试。")
     parser.add_argument("--ref-audio", required=True, help="Reference audio for voice cloning.")
     parser.add_argument("--emo-audio", default=None, help="Emotion reference audio.")
@@ -170,7 +253,15 @@ def parse_args():
     parser.add_argument("--emo-alpha", type=float, default=None, help="Emotion weight in [0, 1].")
     parser.add_argument("--use-emo-text", action="store_true", help="Infer emotion vector from emo-text or text.")
     parser.add_argument("--use-random", action="store_true", help="Use random emotion prototypes.")
-    parser.add_argument("--seed", type=int, default=None)
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=None,
+        help=(
+            "Seed Stage 0 AR sampling and per-request CFM noise; changing the "
+            "concurrent batch composition may still change the final waveform."
+        ),
+    )
     parser.add_argument(
         "--output-dir",
         default=os.path.join(
@@ -180,7 +271,10 @@ def parse_args():
     )
     parser.add_argument("--deploy-config", default=None)
     parser.add_argument("--stage-init-timeout", type=int, default=600)
-    return parser.parse_args()
+    args = parser.parse_args()
+    if args.model_version == "2.5" and not 0.5 <= args.speed <= 2.0:
+        parser.error("IndexTTS 2.5 --speed must be between 0.5 and 2.0")
+    return args
 
 
 if __name__ == "__main__":

examples/offline_inference/text_to_speech/moss_tts_nano/end2end.py

@@ -137,7 +137,7 @@ def main(args) -> None:
     params_list = sampling_params
 
     for stage_outputs in omni.generate(inputs, params_list):
-        for i, req_output in enumerate(stage_outputs.request_output):
+        for i, req_output in enumerate(stage_outputs):
             for j, out in enumerate(req_output.outputs):
                 mm = out.multimodal_output
                 if mm is None:

examples/offline_inference/text_to_speech/omnivoice/end2end.py

@@ -135,7 +135,7 @@ def run_e2e():
     print(f"Received {len(outputs)} outputs.")
     for i, output in enumerate(outputs):
         try:
-            ro = output.request_output
+            ro = output
             if ro is None:
                 print("No request_output found.")
                 continue

examples/offline_inference/text_to_speech/qwen3_tts/end2end.py

@@ -391,7 +391,7 @@ def main(args):
     for batch_start in range(0, len(inputs), batch_size):
         batch = inputs[batch_start : batch_start + batch_size]
         for stage_outputs in omni.generate(batch):
-            output = stage_outputs.request_output
+            output = stage_outputs
             _save_wav(output_dir, output.request_id, output.outputs[0].multimodal_output)
 
 
@@ -412,7 +412,7 @@ async def main_streaming(args):
         t_prev = t_start
         chunk_idx = 0
         async for stage_output in omni.generate(prompt, request_id=request_id):
-            mm = stage_output.request_output.outputs[0].multimodal_output
+            mm = stage_output.outputs[0].multimodal_output
             if not stage_output.finished:
                 t_now = time.perf_counter()
                 audio = mm.get("audio")

examples/offline_inference/text_to_speech/qwen3_tts/word_timestamps.py

@@ -116,7 +116,7 @@ def main(args: Any) -> None:
     prompt = _build_custom_voice_input(args)
     final_output = None
     for stage_outputs in omni.generate([prompt]):
-        final_output = stage_outputs.request_output
+        final_output = stage_outputs
     if final_output is None:
         raise RuntimeError("Qwen3-TTS did not produce an output.")
 

examples/offline_inference/text_to_speech/soulxsinger/benchmark.py

@@ -38,7 +38,7 @@ def _stage_durations_from_output(outputs) -> dict[str, float]:
     durations = getattr(omni_out, "stage_durations", None) or {}
     if durations:
         return dict(durations)
-    ro = getattr(omni_out, "request_output", None)
+    ro = omni_out
     if ro is not None:
         return dict(getattr(ro, "stage_durations", None) or {})
     return {}

examples/offline_inference/text_to_speech/soulxsinger/end2end.py

@@ -99,7 +99,7 @@ def extract_audio(outputs) -> tuple[np.ndarray, int]:
     out = outputs[0]
     mm = getattr(out, "multimodal_output", None)
     if mm is None:
-        ro = getattr(out, "request_output", None)
+        ro = out
         if ro is not None:
             mm = getattr(ro, "multimodal_output", None)
             if mm is None and ro.outputs:

examples/offline_inference/text_to_video/text_to_video.md

@@ -218,6 +218,9 @@ python text_to_video.py \
 - `--audio-sample-rate`: fallback audio sample rate when the pipeline returns audio.
 - `--quantization`: quantization method (such as `fp8` for FP8).
 - `--flow-shift`: scheduler flow_shift parameter.
+- `--lora-path`: path to PEFT LoRA adapter folder or checkpoint file.
+- `--lora-scale`: scale factor for LoRA weights.
+- `--lora-backend`: backend for loading LoRA adapters. Default: peft. Available options: peft, distill.
 - `--extra-body`: JSON object of model-specific generation params, filtered against the model's declared `extra_body_params` (see [`vllm_omni/model_extras`](../../../vllm_omni/model_extras)). Used by Cosmos3 (see above).
 
 ### Wan2.2-specific

examples/offline_inference/text_to_video/text_to_video.py

@@ -14,6 +14,8 @@ from vllm_omni.diffusion.data import DiffusionParallelConfig
 from vllm_omni.diffusion.utils.param_utils import apply_declared_extra_args
 from vllm_omni.entrypoints.omni import Omni
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+from vllm_omni.lora.request import LoRARequest
+from vllm_omni.lora.utils import stable_lora_int_id
 from vllm_omni.model_extras import get_extra_body_params, get_model_class_name
 from vllm_omni.outputs import OmniRequestOutput
 from vllm_omni.platforms import current_omni_platform
@@ -334,6 +336,29 @@ def parse_args() -> argparse.Namespace:
         action="store_true",
         help="Enable expert parallelism for MoE layers.",
     )
+    parser.add_argument(
+        "--lora-path",
+        type=str,
+        nargs="+",
+        default=None,
+        help="Path to LoRA adapter folder (PEFT format) or concrete LoRA checkpoint files. Loaded at initialization and used for generation."
+        "Note: for Wan2.2 MoE models, two checkpoints positionally mapped to high-noise and low-noise modules.",
+    )
+    parser.add_argument(
+        "--lora-scale",
+        type=float,
+        default=1.0,
+        help="Scale factor for LoRA weights (default: 1.0).",
+    )
+    parser.add_argument(
+        "--lora-backend",
+        type=str,
+        default="peft",
+        choices=["peft", "distill"],
+        help="LoRA backend for loading LoRA adapters. Default: peft"
+        "'peft' loads a PEFT-format adapter folder, used e.g. for RL"
+        "'distill' fuses one or more concrete LoRA checkpoint files, used e.g. for distilled few-step LoRAs",
+    )
     parser.add_argument(
         "--use-hsdp",
         action="store_true",
@@ -365,7 +390,7 @@ def _extract_peak_memory_mb(result: Any) -> float:
         return 0.0
     val = getattr(result, "peak_memory_mb", 0.0)
     if not val:
-        inner = getattr(result, "request_output", None)
+        inner = result
         if isinstance(inner, list):
             inner = inner[0] if inner else None
         val = getattr(inner, "peak_memory_mb", 0.0)
@@ -440,6 +465,12 @@ def main():
         omni_kwargs["cache_backend"] = args.cache_backend
         omni_kwargs["cache_config"] = cache_config
         omni_kwargs["enable_cache_dit_summary"] = args.enable_cache_dit_summary
+    if args.lora_path is not None:
+        lora_path = args.lora_path
+        if len(lora_path) == 1:
+            lora_path = lora_path[0]
+        omni_kwargs["lora_path"] = lora_path
+        omni_kwargs["lora_backend"] = args.lora_backend
 
     # Cosmos3 loads its (gated) guardrail models at build time, so the guardrails
     # gate is an engine-level config (offline analog of the server's --no-guardrails).
@@ -469,6 +500,19 @@ def main():
     print(f"  Video size: {args.width}x{args.height}")
     print(f"{'=' * 60}\n")
 
+    lora_request = None
+    if args.lora_path and args.lora_backend == "peft":
+        if len(args.lora_path) != 1:
+            raise ValueError("Only one LoRA path is expected for PEFT backend.")
+
+        lora_path = args.lora_path[0]
+        lora_request_id = stable_lora_int_id(lora_path)
+        lora_request = LoRARequest(
+            lora_name=Path(lora_path).stem,
+            lora_int_id=lora_request_id,
+            lora_path=lora_path,
+        )
+
     prompt_dict = {"prompt": args.prompt}
     if args.negative_prompt is not None:
         prompt_dict["negative_prompt"] = args.negative_prompt
@@ -476,6 +520,11 @@ def main():
         # Preserve the historical empty-prompt behavior for non-LTX examples.
         prompt_dict["negative_prompt"] = ""
 
+    extra_args = {}
+    if lora_request:
+        extra_args["lora_request"] = lora_request
+        extra_args["lora_scale"] = args.lora_scale
+
     sampling_kwargs = dict(
         height=args.height,
         width=args.width,
@@ -483,6 +532,7 @@ def main():
         guidance_scale=args.guidance_scale,
         num_inference_steps=args.num_inference_steps,
         num_frames=args.num_frames,
+        extra_args=extra_args,
     )
     if args.guidance_scale_high is not None:
         sampling_kwargs["guidance_scale_2"] = args.guidance_scale_high
@@ -525,8 +575,8 @@ def main():
         if frames.multimodal_output and "audio" in frames.multimodal_output:
             audio = frames.multimodal_output["audio"]
             audio_sample_rate = frames.multimodal_output.get("audio_sample_rate", audio_sample_rate)
-        if frames.is_pipeline_output and frames.request_output is not None:
-            inner_output = frames.request_output
+        if frames.is_pipeline_output and frames is not None:
+            inner_output = frames
             if isinstance(inner_output, OmniRequestOutput):
                 if inner_output.multimodal_output and "audio" in inner_output.multimodal_output:
                     audio = inner_output.multimodal_output["audio"]

examples/offline_inference/x_to_video_audio/x_to_video_audio.py

@@ -138,7 +138,7 @@ def _extract_peak_memory_mb(result: Any) -> float:
         return 0.0
     val = getattr(result, "peak_memory_mb", 0.0)
     if not val:
-        inner = getattr(result, "request_output", None)
+        inner = result
         if isinstance(inner, list):
             inner = inner[0] if inner else None
         val = getattr(inner, "peak_memory_mb", 0.0)

examples/online_serving/image_to_video/README.md

@@ -1,6 +1,9 @@
 # Image-To-Video
 
-This example demonstrates how to deploy the Wan2.2 image-to-video model for online video generation using vLLM-Omni.
+This example demonstrates online image-to-video generation with vLLM-Omni.
+The startup script defaults to Wan2.2, but `MODEL` can select any supported
+image-to-video model. The existing curl helper remains a concrete Wan2.2
+request through the standard Videos API.
 
 ## Start Server
 
@@ -20,9 +23,7 @@ bash run_server.sh
 
 The script allows overriding:
 - `MODEL` (default: `Wan-AI/Wan2.2-I2V-A14B-Diffusers`)
-- `PORT` (default: `8091`)
-- `BOUNDARY_RATIO` (default: `0.875`)
-- `FLOW_SHIFT` (default: `12.0`)
+- `PORT` (default: `8099`)
 - `CACHE_BACKEND` (default: `none`)
 - `ENABLE_CACHE_DIT_SUMMARY` (default: `0`)
 

examples/online_serving/image_to_video/run_server.sh

@@ -1,12 +1,12 @@
 #!/bin/bash
-# Wan2.2 image-to-video server start script
+# Shared image-to-video server start script
 
 MODEL="${MODEL:-Wan-AI/Wan2.2-I2V-A14B-Diffusers}"
 PORT="${PORT:-8099}"
 CACHE_BACKEND="${CACHE_BACKEND:-none}"
 ENABLE_CACHE_DIT_SUMMARY="${ENABLE_CACHE_DIT_SUMMARY:-0}"
 
-echo "Starting Wan2.2 I2V server..."
+echo "Starting image-to-video server..."
 echo "Model: $MODEL"
 echo "Port: $PORT"
 echo "Cache backend: $CACHE_BACKEND"

examples/online_serving/text_to_image/README.md

@@ -1,6 +1,9 @@
 # Text-To-Image
 
-This example demonstrates how to deploy Qwen-Image model for online image generation service using vLLM-Omni.
+This example demonstrates online text-to-image generation with vLLM-Omni. The
+startup script and Python clients default to Qwen-Image, but `MODEL` can select
+any supported text-to-image model. The existing curl helper remains a concrete
+Qwen-Image request through the standard Images API.
 
 ## Start Server
 
@@ -115,7 +118,23 @@ python gradio_demo.py
 
 ## LoRA
 
-This example supports Peft-compatible LoRA (Low-Rank Adaptation) adapters for diffusion models. The LoRA adapter path must be readable on the **server** machine (usually a local path or a mounted directory).
+This example supports both startup-time distilled LoRAs and request-time
+PEFT-compatible adapters. The LoRA path must be readable on the **server**
+machine (usually a local path or a mounted directory).
+
+### Start Server with a Distilled LoRA
+
+```bash
+vllm serve Qwen/Qwen-Image-2512 \
+  --omni \
+  --port 8091 \
+  --lora-backend distill \
+  --lora-path /path/to/Qwen-Image-2512-Lightning-4steps.safetensors
+```
+
+The distilled LoRA is fused once during server initialization and applies to
+every request. Use the checkpoint's few-step sampling settings, for example
+`num_inference_steps=4` and `true_cfg_scale=1.0`.
 
 ### Using Python Client with LoRA
 
@@ -226,8 +245,8 @@ count, use `size` and `n` rather than `height`, `width`, or
 | `height`                 | int   | None    | Image height in pixels         |
 | `width`                  | int   | None    | Image width in pixels          |
 | `size`                   | str   | None    | Image size (e.g., "1024x1024") |
-| `num_inference_steps`    | int   | 50      | Number of denoising steps      |
-| `true_cfg_scale`         | float | 4.0     | Qwen-Image CFG scale           |
+| `num_inference_steps`    | int   | model   | Number of denoising steps      |
+| `true_cfg_scale`         | float | model   | True CFG scale when supported  |
 | `seed`                   | int   | None    | Random seed (reproducible)     |
 | `negative_prompt`        | str   | None    | Negative prompt                |
 | `num_outputs_per_prompt` | int   | 1       | Number of images to generate   |

examples/online_serving/text_to_image/gradio_demo.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-Qwen-Image Gradio Demo for online serving.
+Shared text-to-image Gradio demo for online serving.
 
 Usage:
     python gradio_demo.py [--server http://localhost:8091] [--port 7860]
@@ -77,9 +77,9 @@ def generate_image(
 def create_demo(server_url: str):
     """Create Gradio demo interface."""
 
-    with gr.Blocks(title="Qwen-Image Demo") as demo:
-        gr.Markdown("# Qwen-Image Online Generation")
-        gr.Markdown("Generate images using Qwen-Image model")
+    with gr.Blocks(title="Text-to-Image Demo") as demo:
+        gr.Markdown("# Text-to-Image Online Generation")
+        gr.Markdown("Generate images using the model configured on the server")
 
         with gr.Row():
             with gr.Column(scale=1):
@@ -115,7 +115,6 @@ def create_demo(server_url: str):
                         label="Inference Steps",
                         minimum=10,
                         maximum=100,
-                        # Default steps aligned with run_curl_text_to_image.sh to 100
                         value=100,
                         step=5,
                     )
@@ -173,7 +172,7 @@ def create_demo(server_url: str):
 
 
 def main():
-    parser = argparse.ArgumentParser(description="Qwen-Image Gradio Demo")
+    parser = argparse.ArgumentParser(description="Shared text-to-image Gradio demo")
     parser.add_argument("--server", default="http://localhost:8091", help="Server URL")
     parser.add_argument("--port", type=int, default=7860, help="Gradio port")
     parser.add_argument("--share", action="store_true", help="Create public link")

examples/online_serving/text_to_image/openai_chat_client.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-Qwen-Image OpenAI-compatible image generation client.
+Shared OpenAI-compatible text-to-image generation client.
 
 Usage:
     python openai_chat_client.py --prompt "A beautiful landscape" --output output.png
@@ -39,7 +39,7 @@ def generate_image(
         height: Image height in pixels
         width: Image width in pixels
         steps: Number of diffusion steps
-        true_cfg_scale: Qwen-Image CFG scale
+        true_cfg_scale: True CFG scale for models that support it
         seed: Random seed
         negative_prompt: Negative prompt
         num_outputs_per_prompt: Number of images to generate
@@ -70,7 +70,7 @@ def generate_image(
         payload["num_inference_steps"] = steps
     if true_cfg_scale is not None:
         payload["true_cfg_scale"] = true_cfg_scale
-    if negative_prompt:
+    if negative_prompt is not None:
         payload["negative_prompt"] = negative_prompt
     if seed is not None:
         payload["seed"] = seed
@@ -115,15 +115,15 @@ def generate_image(
 
 
 def main():
-    parser = argparse.ArgumentParser(description="Qwen-Image chat client")
+    parser = argparse.ArgumentParser(description="Shared text-to-image client")
     parser.add_argument("--prompt", "-p", default="a cup of coffee on the table", help="Text prompt")
-    parser.add_argument("--output", "-o", default="qwen_image_output.png", help="Output file")
+    parser.add_argument("--output", "-o", default="text_to_image_output.png", help="Output file")
     parser.add_argument("--server", "-s", default="http://localhost:8091", help="Server URL")
-    parser.add_argument("--height", type=int, default=1024, help="Image height")
-    parser.add_argument("--width", type=int, default=1024, help="Image width")
-    parser.add_argument("--steps", type=int, default=50, help="Inference steps")
-    parser.add_argument("--cfg-scale", type=float, default=4.0, help="True CFG scale")
-    parser.add_argument("--seed", type=int, default=0, help="Random seed")
+    parser.add_argument("--height", type=int, help="Image height; defaults to the model setting")
+    parser.add_argument("--width", type=int, help="Image width; defaults to the model setting")
+    parser.add_argument("--steps", type=int, help="Inference steps; defaults to the model setting")
+    parser.add_argument("--cfg-scale", type=float, help="True CFG scale when supported")
+    parser.add_argument("--seed", type=int, help="Random seed")
     parser.add_argument("--negative", help="Negative prompt")
 
     parser.add_argument("--lora-path", default=None, help="Server-local LoRA adapter folder (PEFT format)")

examples/online_serving/text_to_image/run_server.sh

@@ -1,10 +1,10 @@
 #!/bin/bash
-# Qwen-Image online serving startup script
+# Shared text-to-image online serving startup script
 
 MODEL="${MODEL:-Qwen/Qwen-Image}"
 PORT="${PORT:-8091}"
 
-echo "Starting Qwen-Image server..."
+echo "Starting text-to-image server..."
 echo "Model: $MODEL"
 echo "Port: $PORT"
 

examples/online_serving/text_to_speech/README.md

@@ -16,7 +16,8 @@ For the full list of supported architectures across all modalities, see
 |---|---|---|---|---|---|
 | Fish Speech S2 Pro | `fishaudio/s2-pro` | ✓ (`ref_audio`+`ref_text`) | ✓ (PCM stream) | — | ✓ |
 | GLM-TTS | `zai-org/GLM-TTS` | ✓ (`ref_audio`+`ref_text`, required) | ✓ (PCM stream) | — | ✓ |
-| IndexTTS-2 | `IndexTeam/IndexTTS-2` | ✓ (`ref_audio` or uploaded `voice`) | compat only, non-chunk | uploaded audio voice only; no presets | — |
+| IndexTTS-2 | `IndexTeam/IndexTTS-2` | ✓ (`ref_audio` or uploaded `voice`) | `stream=true` response, non-chunk | uploaded audio voice only; no presets | — |
+| IndexTTS-2.5 | native `checkpoints/` bundle | ✓ (`ref_audio` or uploaded `voice`) | `stream=true` response, non-chunk | uploaded audio voice only; no presets | — |
 | Ming-omni-tts | `inclusionAI/Ming-omni-tts-0.5B` | ✓ (`ref_audio` / `speaker_embedding`) | ✓ (PCM stream) | IP labels + structured `instructions` | — |
 | Ming-flash-omni-TTS | `Jonathan1909/Ming-flash-omni-2.0` | — (caption-controlled) | — | caption fields (`instructions`) | — |
 | MOSS-TTS-Nano | `OpenMOSS-Team/MOSS-TTS-Nano` | ✓ (`ref_audio` required) | ✓ (PCM stream) | — | ✓ |
@@ -138,15 +139,29 @@ bash examples/online_serving/text_to_speech/glm_tts/run_gradio_demo.sh
 
 ---
 
-## IndexTTS-2
+## IndexTTS-2 and IndexTTS-2.5
 
-2-stage TTS (GPT AR + S2Mel CFM DiT + BigVGAN) at 22.05 kHz. Requests use `ref_audio` for voice cloning, or an uploaded audio `voice` from `/v1/audio/voices`. Supports emotion conditioning via `emo_audio`, `emo_text`, or `emo_vector` passed in `extra_params`.
+2-stage TTS at 22.05 kHz. Requests use `ref_audio` for voice cloning, or an uploaded audio `voice` from `/v1/audio/voices`. IndexTTS-2.5 uses a multilingual tokenizer, CAMPPlus speaker projection, EnhancedCodec, and code-only Stage 0→1 transfer by default. Both versions support emotion conditioning via `emo_audio`, `emo_text`, or `emo_vector` passed in `extra_params`.
+
+### Prerequisites
+
+IndexTTS-2 uses its existing frontend and does not require the IndexTTS-2.5 text dependencies. Before launching IndexTTS-2.5, install its optional frontend dependencies:
+
+```bash
+pip install 'vllm-omni[indextts2]'
+```
 
 ### Launch
 ```bash
 vllm serve IndexTeam/IndexTTS-2 --omni --trust-remote-code --port 8092
 # or, to pass the bundled deploy config explicitly:
 bash examples/online_serving/text_to_speech/indextts2/run_server.sh
+
+# IndexTTS-2.5 default: use_gpt_latent=false
+MODEL_VERSION=2.5 \
+MODEL=/path/to/indextts-2.5 \
+bash examples/online_serving/text_to_speech/indextts2/run_server.sh
+
 ```
 
 ### Sending requests
@@ -161,14 +176,35 @@ python examples/online_serving/text_to_speech/indextts2/speech_client.py \
     --text "今天心情很好！" \
     --ref-audio /path/to/ref.wav \
     --emo-audio /path/to/happy.wav
+
+# IndexTTS-2.5 Japanese request
+python examples/online_serving/text_to_speech/indextts2/speech_client.py \
+    --model-version 2.5 \
+    --model /path/to/indextts-2.5 \
+    --lang ja \
+    --text "こんにちは、音声合成のテストです。" \
+    --ref-audio /path/to/ref.wav
+
+# IndexTTS-2.5 native speed control
+python examples/online_serving/text_to_speech/indextts2/speech_client.py \
+    --model-version 2.5 \
+    --model /path/to/indextts-2.5 \
+    --speed 2.0 \
+    --text "这是两倍速度的语音合成测试。" \
+    --ref-audio /path/to/ref.wav
 ```
 
 ### Notes
 - Output: 22.05 kHz mono WAV.
-- Provide `ref_audio` on the documented raw request path, or pass `voice` only when it names an uploaded audio voice; IndexTTS-2 does not provide a built-in text-only preset voice.
+- Provide `ref_audio` on the documented raw request path, or pass `voice` only when it names an uploaded audio voice; neither version provides a built-in text-only preset voice.
+- IndexTTS-2.5 request controls `lang` and `text_normalization` are carried in `extra_params`; the client does this for `--model-version 2.5`.
+- IndexTTS-2.5 accepts the public `speed` request field in `[0.5, 2.0]`: `2.0` generates shorter, faster speech and `0.5` generates longer, slower speech. This is native Stage 1 duration control, so serving does not apply the generic playback-speed adjustment a second time. IndexTTS-2 does not use this control.
+- IndexTTS-2.5 accepts language codes such as `zh`, `en`, `zhen` (mixed Chinese/English), `ja`, and `yue`. `Mandarin` is a vLLM-Omni convenience alias for `zh`. Japanese (`ja`) uses `fugashi` tokenization and produces audio, but it does not automatically expand numbers, dates, or percentages; callers should first write those inputs as readable Japanese text.
+- A request `seed` controls Stage 0 AR sampling and per-request CFM noise. Different concurrent batch compositions do not guarantee a bit-identical waveform.
+- IndexTTS-2.5 Stage 0 uses plain vLLM sampling and does not reproduce the official default `num_beams=3` beam search. For parity comparisons, run upstream with `num_beams=1`; output quality can differ from the official beam-search result.
 - Emotion params (`emo_audio`, `emo_text`, `emo_vector`, `emo_alpha`, `use_emo_text`, `use_random`) are passed via the `extra_params` field. Official precedence is `use_emo_text` > `emo_vector` > `emo_audio` > same emotion as the speaker reference.
-- `stream=true` is accepted as an OpenAI-compatible response path, but IndexTTS-2 is not async-chunk streaming; audio is produced after S2Mel receives the full mel-code sequence.
-- Deploy config: `vllm_omni/deploy/indextts2.yaml` (auto-loaded).
+- IndexTTS-2.5 uses `vllm_omni/deploy/indextts2_5.yaml` with the official code-only Stage 0 to Stage 1 contract.
+- For IndexTTS-2.5, set `MODEL` to the local native bundle; asset discovery accepts its nested `checkpoints/` layout.
 
 ---
 
@@ -569,6 +605,13 @@ python qwen3_tts/streaming_speech_client.py \
 The client writes one PCM file per sentence and a matching
 `sentence_XXX_timestamps.json` sidecar.
 
+Non-streaming requests can also ask for timestamps: pass
+`"word_timestamps": true` to `POST /v1/audio/speech` and read the
+`X-Word-Timestamps` response header (JSON list of `{word, start_ms, end_ms}`,
+ASCII-escaped). Past 4 KB the header is replaced by
+`X-Word-Timestamps-Omitted: oversize; bytes=<n>; limit=4096` and the audio
+still returns — use the WebSocket path for long transcripts.
+
 To *see* the alignment instead of reading a JSON sidecar, run the
 word-timestamp Gradio demo (server must be launched with `--forced-aligner`):
 ```bash

examples/online_serving/text_to_speech/indextts2/run_server.sh

@@ -1,20 +1,37 @@
 #!/bin/bash
-# Launch vLLM-Omni server for IndexTTS2
+# Launch vLLM-Omni server for IndexTTS 2.0 or 2.5.
 #
 # Usage from repository root:
 #   examples/online_serving/text_to_speech/indextts2/run_server.sh
-#   CUDA_VISIBLE_DEVICES=0 PORT=8092 MODEL=/path/to/IndexTeam/IndexTTS-2 examples/online_serving/text_to_speech/indextts2/run_server.sh
+#   MODEL_VERSION=2.5 MODEL=/path/to/native/bundle \
+#     examples/online_serving/text_to_speech/indextts2/run_server.sh
 
 set -e
 
 SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
 ROOT_DIR="$(cd -- "$SCRIPT_DIR/../../../.." && pwd)"
 
-MODEL="${MODEL:-IndexTeam/IndexTTS-2}"
+MODEL_VERSION="${MODEL_VERSION:-2.0}"
 PORT="${PORT:-8092}"
-DEPLOY_CONFIG="${DEPLOY_CONFIG:-$ROOT_DIR/vllm_omni/deploy/indextts2.yaml}"
 
-echo "Starting IndexTTS2 server with model: $MODEL"
+if [[ "$MODEL_VERSION" == "2.5" ]]; then
+    if [[ -z "${MODEL:-}" ]]; then
+        echo "Usage: MODEL_VERSION=2.5 MODEL=/path/to/native/bundle bash $0" >&2
+        exit 2
+    fi
+    DEFAULT_DEPLOY_CONFIG="$ROOT_DIR/vllm_omni/deploy/indextts2_5.yaml"
+elif [[ "$MODEL_VERSION" == "2.0" ]]; then
+    MODEL="${MODEL:-IndexTeam/IndexTTS-2}"
+    DEFAULT_DEPLOY_CONFIG="$ROOT_DIR/vllm_omni/deploy/indextts2.yaml"
+else
+    echo "MODEL_VERSION must be 2.0 or 2.5" >&2
+    exit 2
+fi
+
+DEPLOY_CONFIG="${DEPLOY_CONFIG:-$DEFAULT_DEPLOY_CONFIG}"
+
+echo "Starting IndexTTS $MODEL_VERSION server with model: $MODEL"
+echo "Deploy config: $DEPLOY_CONFIG"
 
 FLASHINFER_DISABLE_VERSION_CHECK=1 \
 vllm serve "$MODEL" \

examples/online_serving/text_to_speech/indextts2/speech_client.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-"""OpenAI-compatible client for IndexTTS2 TTS via /v1/audio/speech endpoint.
+"""OpenAI-compatible client for IndexTTS 2.0/2.5 via /v1/audio/speech.
 
 Examples:
     # With reference audio for voice cloning
@@ -54,13 +54,44 @@ def main() -> None:
     parser.add_argument("--emo-alpha", type=float, default=None, help="Emotion weight in [0, 1]")
     parser.add_argument("--use-emo-text", action="store_true", help="Infer emotion vector from emo-text or text")
     parser.add_argument("--use-random", action="store_true", help="Use random emotion prototypes")
-    parser.add_argument("--model", type=str, default="IndexTeam/IndexTTS-2")
+    parser.add_argument(
+        "--model-version",
+        choices=("2.0", "2.5"),
+        default="2.0",
+    )
+    parser.add_argument("--model", type=str, default=None)
+    parser.add_argument(
+        "--lang",
+        default="zh",
+        help=(
+            "IndexTTS 2.5 language code, for example zh/en/zhen/ja/yue; "
+            "zhen is mixed Chinese/English and Mandarin is a vLLM-Omni alias for zh"
+        ),
+    )
+    parser.add_argument(
+        "--no-text-normalization",
+        action="store_false",
+        dest="text_normalization",
+        help="Disable IndexTTS 2.5 text normalization",
+    )
+    parser.add_argument(
+        "--speed",
+        type=float,
+        default=1.0,
+        help="IndexTTS 2.5 native synthesis speed in [0.5, 2.0]; 2.0 is faster",
+    )
     parser.add_argument("--voice", type=str, default=None, help="Uploaded voice name to use instead of --ref-audio")
     parser.add_argument("--output", type=str, default="output.wav")
     parser.add_argument("--api-base", type=str, default=DEFAULT_API_BASE)
     parser.add_argument("--api-key", type=str, default=DEFAULT_API_KEY)
     parser.add_argument("--response-format", type=str, default="wav")
     args = parser.parse_args()
+    if args.model is None:
+        if args.model_version == "2.5":
+            parser.error("--model is required for IndexTTS 2.5")
+        args.model = "IndexTeam/IndexTTS-2"
+    if args.model_version == "2.5" and not 0.5 <= args.speed <= 2.0:
+        parser.error("IndexTTS 2.5 --speed must be between 0.5 and 2.0")
 
     if not args.ref_audio and not args.voice:
         parser.error("IndexTTS2 requires --ref-audio or --voice for voice cloning")
@@ -97,6 +128,10 @@ def main() -> None:
         extra_params["use_emo_text"] = True
     if args.use_random:
         extra_params["use_random"] = True
+    if args.model_version == "2.5":
+        payload["speed"] = args.speed
+        extra_params["lang"] = args.lang
+        extra_params["text_normalization"] = args.text_normalization
     if extra_params:
         payload["extra_params"] = extra_params
 

mkdocs.yml

@@ -111,6 +111,7 @@ plugins:
         - "vllm_omni.entrypoints.openai"  # avoid importing vllm in mkdocs building
         - "vllm_omni.entrypoints.openai.protocol"  # avoid importing vllm in mkdocs building
         - "vllm_omni.experimental"  # avoid importing optional serving deps (openai, fastapi, uvicorn, httpx) in mkdocs building
+        - "vllm_omni.model_executor.models.nemotron_voicechat.nemo_vendored"  # vendored NeMo code; upstream docstrings trip griffe strict warnings
   - mkdocstrings:
       handlers:
         python:

pyproject.toml

@@ -84,6 +84,13 @@ forced-aligner = [
     "qwen-asr>=0.0.6",  # faithful Japanese/Korean word segmentation for the TTS forced aligner
 ]
 
+indextts2 = [
+    "fugashi>=1.2.0",
+    "unidic-lite>=1.0.0",
+    "wetext>=0.0.9; sys_platform != 'linux'",
+    "WeTextProcessing; sys_platform == 'linux'",
+]
+
 # Local-test-only extras
 local = [
     "FlagEmbedding",
@@ -199,6 +206,12 @@ ignore = [
 # These files keep upstream conventions (star imports, long lines, math-symbol
 # argument names) so they stay easy to diff against upstream releases.
 "vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_omni_llm.py" = ["E402", "E501", "F403", "F405", "N803"]
+# NemotronVoiceChat inference modules vendored from NVIDIA-NeMo/Speech (branch
+# nemotron-labs-voicechat). Numerics-bearing code is kept byte-close to
+# upstream to stay diffable and parity-safe, so upstream style (long lines,
+# legacy typing, whitespace, unused-import shims) is exempted. TID251 and the
+# F-correctness rules still apply.
+"vllm_omni/model_executor/models/nemotron_voicechat/nemo_vendored/**" = ["E501", "E721", "E741", "F401", "F841", "I001", "N803", "N814", "UP006", "UP007", "UP008", "UP011", "UP032", "UP035", "W291", "W293"]
 "vllm_omni/experimental/fullduplex/joyvl/decision/prompts.py" = ["E501"]  # System/summarizer prompts are long prose lines
 
 [tool.ruff.lint.flake8-tidy-imports.banned-api]
@@ -307,6 +320,10 @@ extend-ignore-identifiers-re = [
     ".*[Nn][Dd]3.*",
     ".*updator.*",
     "byt5.*",
+    # NemotronVoiceChat vendored triton kernel: dout/DOUT abbreviate d_out
+    # (output feature dim), not "doubt".
+    ".*dout.*",
+    ".*DOUT.*",
 ]
 extend-ignore-re = [
     "\\.\\.\\.n,d->\\.\\.\\.nd",
@@ -327,3 +344,10 @@ byt5 = "byt5"
 # "seeked" is the standard HTML media element DOM event name (fires when a
 # seek completes), used by the word-timestamps Gradio demo. Not a typo.
 seeked = "seeked"
+# Ryan Leary: author credited in the NemotronVoiceChat vendored NeMo
+# features.py copyright header. A surname, not a typo of "leery".
+Leary = "Leary"
+# IndexTTS 2.5 language codes and speech-emotion-recognition event token.
+fo = "fo"
+ba = "ba"
+SER = "SER"

recipes/IndexTeam/IndexTTS-2_5.md

@@ -0,0 +1,308 @@
+# IndexTTS-2.5 for multilingual voice-cloned TTS on 1x GPU
+
+## Summary
+
+- Vendor: IndexTeam
+- Model: `IndexTeam/IndexTTS-2.5`
+- Task: Multilingual text-to-speech with voice cloning, emotion control, and
+  native speed control
+- Mode: Online serving with the OpenAI-compatible `/v1/audio/speech` API, or
+  offline inference through `Omni`
+- Maintainer: Community
+
+## When to use this recipe
+
+Use this recipe to serve IndexTTS-2.5 as a two-stage TTS system. Stage 0 is an
+autoregressive talker; Stage 1 uses EnhancedCodec, S2Mel CFM/DiT, and BigVGAN
+to produce 22.05 kHz mono speech. Each request supplies synthesis text and
+reference audio, or an uploaded audio voice, for zero-shot voice cloning.
+
+IndexTTS-2.5 adds multilingual text processing and model-native speed control
+to the IndexTTS-2 serving contract.
+
+## References
+
+- Upstream model:
+  [IndexTeam/IndexTTS-2.5 on Hugging Face](https://huggingface.co/IndexTeam/IndexTTS-2.5)
+- Online serving example:
+  [`examples/online_serving/text_to_speech/README.md#indextts-2-and-indextts-25`](../../examples/online_serving/text_to_speech/README.md#indextts-2-and-indextts-25)
+- Offline inference example:
+  [`examples/offline_inference/text_to_speech/README.md#indextts-2-and-indextts-25`](../../examples/offline_inference/text_to_speech/README.md#indextts-2-and-indextts-25)
+- OpenAI-compatible client:
+  [`examples/online_serving/text_to_speech/indextts2/speech_client.py`](../../examples/online_serving/text_to_speech/indextts2/speech_client.py)
+- Standard deploy config:
+  [`vllm_omni/deploy/indextts2_5.yaml`](../../vllm_omni/deploy/indextts2_5.yaml)
+
+## Hardware Support
+
+### GPU
+
+### 1x NVIDIA H20 96GB
+
+#### Environment
+
+- OS: Linux
+- Python: 3.10+
+- Driver / runtime: NVIDIA CUDA environment
+- vLLM version: Match the repository requirements for your checkout
+- vLLM-Omni version or commit: Use the commit you are deploying from
+
+Install vLLM-Omni with the IndexTTS text-processing dependencies:
+
+```bash
+pip install 'vllm-omni[indextts2]'
+```
+
+Obtain the native IndexTTS-2.5 bundle and point `MODEL` at its root. The model
+loader accepts the upstream nested `checkpoints/` layout.
+
+#### Command
+
+Start the standard code-only server from the repository root:
+
+```bash
+MODEL_VERSION=2.5 \
+MODEL=/path/to/indextts-2.5 \
+bash examples/online_serving/text_to_speech/indextts2/run_server.sh
+```
+
+This selects `vllm_omni/deploy/indextts2_5.yaml`, which uses
+`use_gpt_latent=false`. To launch directly:
+
+```bash
+vllm serve /path/to/indextts-2.5 \
+  --omni \
+  --trust-remote-code \
+  --port 8092 \
+  --deploy-config vllm_omni/deploy/indextts2_5.yaml
+```
+
+#### Optional: NVIDIA MPS for higher single-GPU throughput
+
+Stage 0 and Stage 1 run in separate processes on the same GPU. Enabling
+NVIDIA Multi-Process Service (MPS) can improve steady-state throughput by
+allowing work from both stages to overlap more effectively. MPS is an opt-in
+deployment optimization: this recipe does not start it automatically, and the
+gain depends on the request mix and concurrency, so benchmark it with the
+intended workload before enabling it in production.
+
+Pay attention to CUDA device renumbering. For example, if the MPS control
+daemon is started with physical `CUDA_VISIBLE_DEVICES=1`, that GPU is exposed
+to MPS clients as logical device `0`; launch the server with
+`CUDA_VISIBLE_DEVICES=0`, not `1`. Use a dedicated MPS pipe/log directory when
+the host is shared with other services, and stop only the MPS daemon owned by
+this deployment.
+
+#### Verification
+
+Send a multilingual voice-cloning request with the bundled client. Local audio
+paths are converted to base64 data URLs before transmission:
+
+```bash
+python examples/online_serving/text_to_speech/indextts2/speech_client.py \
+  --api-base http://localhost:8092 \
+  --model-version 2.5 \
+  --model /path/to/indextts-2.5 \
+  --lang zh \
+  --text "你好，这是 IndexTTS-2.5 语音合成测试。" \
+  --ref-audio /path/to/reference.wav \
+  --output indextts2_5.wav
+```
+
+##### Native speed control
+
+The public `speed` field is handled natively. Its accepted range is
+`[0.5, 2.0]`; values above `1.0` produce shorter, faster speech. The serving
+adapter converts the API convention to the model-native control with
+`duration_factor = 1.0 / speed`, so `speed=1.25` uses
+`duration_factor=0.8`:
+
+```bash
+python examples/online_serving/text_to_speech/indextts2/speech_client.py \
+  --api-base http://localhost:8092 \
+  --model-version 2.5 \
+  --model /path/to/indextts-2.5 \
+  --speed 1.25 \
+  --text "这是使用模型原生语速控制的测试。" \
+  --ref-audio /path/to/reference.wav \
+  --output indextts2_5_speed.wav
+```
+
+##### Upload and reuse a named voice
+
+Upload a reference recording once when callers should reuse the same voice
+without sending `ref_audio` on every request. `consent` is required by the
+voice-storage API:
+
+```bash
+curl -X POST http://localhost:8092/v1/audio/voices \
+  -F "audio_sample=@/path/to/reference.wav" \
+  -F "consent=user-consent-id" \
+  -F "name=indextts_demo_voice" \
+  -F "speaker_description=IndexTTS-2.5 demonstration voice"
+```
+
+Confirm that the voice was stored, then synthesize with its name instead of a
+reference-audio payload:
+
+```bash
+curl http://localhost:8092/v1/audio/voices
+
+python examples/online_serving/text_to_speech/indextts2/speech_client.py \
+  --api-base http://localhost:8092 \
+  --model-version 2.5 \
+  --model /path/to/indextts-2.5 \
+  --voice indextts_demo_voice \
+  --lang zh \
+  --text "你好，这是复用已上传音色的语音合成测试。" \
+  --output indextts2_5_named_voice.wav
+```
+
+There are no built-in text-only preset voices. Each named IndexTTS voice must
+first be created from an uploaded reference recording.
+
+##### Multilingual synthesis and text normalization
+
+The client accepts `zh` (Mandarin), `en` (English), `zhen` (mixed Chinese and
+English), `ja` (Japanese), and `yue` (Cantonese). The following commands use
+the same reference voice across all supported language modes:
+
+```bash
+CLIENT=examples/online_serving/text_to_speech/indextts2/speech_client.py
+MODEL=/path/to/indextts-2.5
+REF_AUDIO=/path/to/reference.wav
+
+python "$CLIENT" --model-version 2.5 --model "$MODEL" \
+  --ref-audio "$REF_AUDIO" --lang zh \
+  --text "你好，这是中文语音合成测试。" --output indextts2_5_zh.wav
+
+python "$CLIENT" --model-version 2.5 --model "$MODEL" \
+  --ref-audio "$REF_AUDIO" --lang en \
+  --text "Hello, this is an English speech synthesis test." \
+  --output indextts2_5_en.wav
+
+python "$CLIENT" --model-version 2.5 --model "$MODEL" \
+  --ref-audio "$REF_AUDIO" --lang zhen \
+  --text "Hello，欢迎使用 IndexTTS 二点五。" --output indextts2_5_zhen.wav
+
+python "$CLIENT" --model-version 2.5 --model "$MODEL" \
+  --ref-audio "$REF_AUDIO" --lang ja \
+  --text "こんにちは、これは日本語の音声合成テストです。" \
+  --output indextts2_5_ja.wav
+
+python "$CLIENT" --model-version 2.5 --model "$MODEL" \
+  --ref-audio "$REF_AUDIO" --lang yue \
+  --text "你好，呢段係粵語語音合成測試。" --output indextts2_5_yue.wav
+```
+
+Text normalization is enabled by default. Disable it only when the input is
+already written exactly as it should be spoken:
+
+```bash
+python examples/online_serving/text_to_speech/indextts2/speech_client.py \
+  --model-version 2.5 --model /path/to/indextts-2.5 \
+  --ref-audio /path/to/reference.wav --lang en --no-text-normalization \
+  --text "The temperature is twenty five degrees." \
+  --output indextts2_5_pre_normalized.wav
+```
+
+For raw HTTP requests, put the same language and text-normalization controls
+under `extra_params`:
+
+```bash
+curl http://localhost:8092/v1/audio/speech \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "/path/to/indextts-2.5",
+    "input": "This is an IndexTTS-2.5 test.",
+    "response_format": "wav",
+    "speed": 1.0,
+    "ref_audio": "data:audio/wav;base64,<BASE64_ENCODED_AUDIO>",
+    "extra_params": {
+      "lang": "en",
+      "text_normalization": true
+    }
+  }' \
+  --output indextts2_5_en.wav
+```
+
+##### Emotion control
+
+IndexTTS-2.5 supports an explicit eight-value emotion vector, an emotion text
+description, or a separate emotion-reference recording. Use one source at a
+time. Vector values are ordered as `happy`, `angry`, `sad`, `afraid`,
+`disgusted`, `melancholic`, `surprised`, and `calm`; each value must be in
+`[0, 1.2]`. `emo_alpha` controls the strength in `[0, 1]`.
+
+Use an explicit emotion vector for deterministic control:
+
+```bash
+python examples/online_serving/text_to_speech/indextts2/speech_client.py \
+  --model-version 2.5 --model /path/to/indextts-2.5 \
+  --ref-audio /path/to/reference.wav --lang zh \
+  --text "今天真是令人开心的一天！" \
+  --emo-vector 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \
+  --emo-alpha 0.8 --output indextts2_5_happy_vector.wav
+```
+
+Infer the emotion from a natural-language description with `use_emo_text`:
+
+```bash
+python examples/online_serving/text_to_speech/indextts2/speech_client.py \
+  --model-version 2.5 --model /path/to/indextts-2.5 \
+  --ref-audio /path/to/reference.wav --lang zh \
+  --text "我们终于完成了这项工作！" \
+  --use-emo-text --emo-text "开心、兴奋而且充满活力" \
+  --emo-alpha 0.8 --output indextts2_5_happy_text.wav
+```
+
+Transfer emotion from a recording while retaining the speaker identity from
+`ref_audio`:
+
+```bash
+python examples/online_serving/text_to_speech/indextts2/speech_client.py \
+  --model-version 2.5 --model /path/to/indextts-2.5 \
+  --ref-audio /path/to/reference.wav --lang zh \
+  --text "请用情绪参考音频中的表达方式朗读这句话。" \
+  --emo-audio /path/to/emotion_reference.wav \
+  --emo-alpha 0.8 --output indextts2_5_emotion_audio.wav
+```
+
+If multiple emotion sources are supplied, the official precedence is
+`use_emo_text` > `emo_vector` > `emo_audio` > the emotion in the speaker
+reference. `--use-random` is also available for exploratory random emotion
+prototypes, but should not be used when reproducible conditioning is required.
+
+For offline inference:
+
+```bash
+python examples/offline_inference/text_to_speech/indextts2/end2end.py \
+  --model /path/to/indextts-2.5 \
+  --model-version 2.5 \
+  --lang zh \
+  --speed 1.0 \
+  --text "你好，这是离线语音合成测试。" \
+  --ref-audio /path/to/reference.wav
+```
+
+#### Notes
+
+- Hardware scope: the standard recipe has been exercised on one NVIDIA H200.
+  It does not claim an unverified throughput or quality result.
+- Audio output: 22.05 kHz mono WAV.
+- Voice cloning: reference audio is required on the documented raw request
+  path. Alternatively, `voice` may name an uploaded audio voice; there is no
+  built-in text-only preset voice.
+- Native speed: serving maps `speed` to the model's duration factor and skips
+  generic waveform speed adjustment, so speed is applied exactly once.
+- Languages: common codes include `zh`, `en`, `zhen` (mixed Chinese/English),
+  `ja`, and `yue`; `Mandarin` is accepted as an alias for `zh`.
+- Japanese normalization: `ja` tokenization does not automatically expand
+  numbers, dates, or percentages. Write these inputs as readable Japanese text
+  before inference.
+- Emotion controls: `use_emo_text`, `emo_vector`, and `emo_audio` are
+  alternative conditioning modes. Their precedence is `use_emo_text` >
+  `emo_vector` > `emo_audio` > the speaker-reference emotion.
+- Sampling difference: Stage 0 uses plain vLLM sampling, not the upstream
+  default `num_beams=3` beam search. Use upstream `num_beams=1` for parity
+  comparisons; output may differ from the official beam-search result.

recipes/MiniMaxAI/MiniMax-H3-RTX-PRO-5000.md

@@ -0,0 +1,198 @@
+# MiniMax-H3 on RTX PRO 5000 Blackwell GPUs
+
+This recipe runs MiniMax-H3 in BF16 on 72 GiB RTX PRO 5000 Blackwell GPUs. It
+contains the validated two-GPU DLO configuration and the recommended resident
+configurations: TP1 x Ulysses2 with 20 resident layers on two GPUs, TP2 x
+Ulysses2 on four GPUs, and TP4 x Ulysses2 on eight GPUs. The four- and
+eight-GPU routes do not require offload.
+
+## Capacity requirements
+
+| Resource | Requirement |
+| --- | ---: |
+| GPUs | 2, 4, or 8 x RTX PRO 5000 Blackwell |
+| GPU HBM | 72 GiB per GPU |
+| Checkpoint storage | 135 GiB per partition |
+| Available system RAM | 200 GiB minimum |
+| Recommended system RAM | 384 GiB |
+
+`FL2VA` and `Ref2VA` are separate checkpoint partitions. Start one server at a
+time on a host sized for the minimum system-memory requirement.
+
+## PCIe topology and GPU order
+
+RTX PRO 5000 does not provide NVLink. Before starting the server, identify the
+closest PCIe pairs and their NUMA affinity:
+
+```bash
+nvidia-smi topo -m
+nvidia-smi nvlink -s
+```
+
+For two GPUs, select the closest PCIe pair on one NUMA node. For four GPUs,
+select all cards from one NUMA node. On the validated host,
+physical GPUs `(0,1)` and `(2,3)` are the two `PXB` pairs on NUMA node 0. The
+order `CUDA_VISIBLE_DEVICES=0,2,1,3` maps the Ulysses groups to those local
+pairs. For eight GPUs, the validated order is `0,4,1,5,2,6,3,7`, with host
+memory interleaved across NUMA nodes 0 and 1. Do not copy these IDs blindly:
+reproduce the same PCIe and NUMA relationships on the target host.
+
+## Recommended serving configurations
+
+### Two GPUs
+
+Two 72 GiB cards require distributed layerwise offload. The validated route
+uses TP1 x Ulysses2, keeps 20 leading DiT layers resident, and streams
+rank-local weights without AllGather. Eager execution avoids regional-compile
+instability on this offload path.
+
+```bash
+export MODEL_ROOT=/path/to/MiniMax-H3
+export MODEL="${MODEL_ROOT}/FL2VA"
+export PORT=8091
+
+CUDA_VISIBLE_DEVICES=0,1 \
+VLLM_WORKER_MULTIPROC_METHOD=spawn \
+VLLM_OMNI_VIDEO_SYNC_TIMEOUT=1800 \
+numactl --cpunodebind=0 --membind=0 \
+vllm serve "${MODEL}" \
+  --omni \
+  --host 0.0.0.0 \
+  --port "${PORT}" \
+  --trust-remote-code \
+  --num-gpus 2 \
+  --tensor-parallel-size 1 \
+  --usp 2 \
+  --ring 1 \
+  --text-encoder-tp-size 2 \
+  --vae-patch-parallel-size 2 \
+  --vae-parallel-mode tile \
+  --vae-use-tiling \
+  --diffusion-attention-backend CUDNN_ATTN \
+  --enable-distributed-layerwise-offload \
+  --dlo-no-use-allgather \
+  --dlo-resident-layers 20 \
+  --enforce-eager
+```
+
+### Four GPUs
+
+The validated baseline uses TP2 x Ulysses2, text-encoder TP4, VAE patch
+parallelism 4, and explicit cuDNN BF16 attention. Selecting the backend
+explicitly keeps the recipe independent of platform-default backend changes.
+
+```bash
+export MODEL_ROOT=/path/to/MiniMax-H3
+export MODEL="${MODEL_ROOT}/FL2VA"
+export PORT=8091
+
+CUDA_VISIBLE_DEVICES=0,2,1,3 \
+VLLM_WORKER_MULTIPROC_METHOD=spawn \
+VLLM_OMNI_VIDEO_SYNC_TIMEOUT=1800 \
+numactl --cpunodebind=0 --membind=0 \
+vllm serve "${MODEL}" \
+  --omni \
+  --host 0.0.0.0 \
+  --port "${PORT}" \
+  --trust-remote-code \
+  --num-gpus 4 \
+  --tensor-parallel-size 2 \
+  --usp 2 \
+  --ring 1 \
+  --text-encoder-tp-size 4 \
+  --vae-patch-parallel-size 4 \
+  --vae-parallel-mode tile \
+  --vae-use-tiling \
+  --diffusion-attention-backend CUDNN_ATTN
+```
+
+### Eight GPUs
+
+The recommended eight-GPU route uses TP4 x Ulysses2, text-encoder TP8, VAE
+patch parallelism 8, and host-memory interleaving across both NUMA nodes.
+
+```bash
+export MODEL_ROOT=/path/to/MiniMax-H3
+export MODEL="${MODEL_ROOT}/FL2VA"
+export PORT=8091
+
+CUDA_VISIBLE_DEVICES=0,4,1,5,2,6,3,7 \
+VLLM_WORKER_MULTIPROC_METHOD=spawn \
+VLLM_OMNI_VIDEO_SYNC_TIMEOUT=1800 \
+numactl --interleave=0,1 \
+vllm serve "${MODEL}" \
+  --omni \
+  --host 0.0.0.0 \
+  --port "${PORT}" \
+  --trust-remote-code \
+  --num-gpus 8 \
+  --tensor-parallel-size 4 \
+  --usp 2 \
+  --ring 1 \
+  --text-encoder-tp-size 8 \
+  --vae-patch-parallel-size 8 \
+  --vae-parallel-mode tile \
+  --vae-use-tiling \
+  --diffusion-attention-backend CUDNN_ATTN
+```
+
+For the four- and eight-GPU resident routes, do not add `--enforce-eager`.
+Warm the server once before measuring so regional compilation is outside the
+measured request. The two-GPU DLO route intentionally remains eager.
+
+For Ref2VA, stop the FL2VA server and restart the same command with
+`MODEL="${MODEL_ROOT}/Ref2VA"`.
+
+## Target-hardware validation
+
+All three configurations were exercised on a PCIe-only, dual-socket host with
+eight RTX PRO 5000 GPUs. The run used PyTorch 2.11.0+cu130, CUDA 13.0, driver
+580.95.05, 1344x768 output, 124 frames, and two warmups.
+
+The four-GPU route also received a five-step profiling validation for GPU
+balance:
+
+| Measurement | Result |
+| --- | ---: |
+| Maximum externally sampled peak | 69,219 MiB (67.60 GiB) per GPU |
+| T2VA worker-reported peak | 65,314 MiB |
+| First-frame FL2VA worker-reported peak | 66,780 MiB |
+| T2VA maximum GPU kernel-time deviation | 0.56% |
+| First-frame FL2VA maximum GPU kernel-time deviation | 0.09% |
+
+The recommended routes produced the following 50-step results. MiniMax-H3
+requested 50 denoise steps and executed 49 denoise updates, so per-step latency
+is `denoise / 49`.
+
+| GPUs | Workload | Parallelism | E2E (s) | Text encode (s) | Denoise (s) | VAE decode (s) | Per step (ms) | Peak memory (GiB) |
+| ---: | --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
+| 2 | T2VA | TP1 x Ulysses2, DLO resident 20 | 515.57 | 1.19 | 504.69 | 8.79 | 10,300 | 36.38 |
+| 2 | FL2VA first-frame I2VA | TP1 x Ulysses2, DLO resident 20 | 553.45 | 1.27 | 541.90 | 8.76 | 11,059 | 36.38 |
+| 4 | T2VA | TP2 x Ulysses2 | 284.01 | 0.03 | 278.73 | 4.36 | 5,688 | 67.58 |
+| 4 | FL2VA first-frame I2VA | TP2 x Ulysses2 | 305.72 | 0.28 | 299.85 | 4.36 | 6,119 | 67.58 |
+| 8 | T2VA | TP4 x Ulysses2 | 163.20 | 0.04 | 159.40 | 2.58 | 3,253 | 45.83 |
+| 8 | FL2VA first-frame I2VA | TP4 x Ulysses2 | 171.62 | 0.27 | 167.25 | 2.57 | 3,413 | 45.83 |
+
+Peak memory is the maximum per-GPU value sampled externally with
+`nvidia-smi`. The two-GPU route leaves about 34.7 GiB below the reported
+73,415 MiB device capacity, the four-GPU route leaves about 4.1 GiB, and the
+eight-GPU route leaves about 25.9 GiB. Re-measure memory for longer reference
+inputs, concurrency greater than one, or a different output shape.
+
+## T2VA request example
+
+```bash
+export API_URL="http://127.0.0.1:${PORT}/v1/videos/sync"
+
+curl -sS --max-time 1800 -X POST "${API_URL}" \
+  -F 'prompt=At night, three cats march into a bedroom playing tiny brass instruments, then abruptly file out, with synchronized room ambience.' \
+  -F 'width=1344' \
+  -F 'height=768' \
+  -F 'aspect_ratio=16:9' \
+  -F 'fps=24' \
+  -F 'num_inference_steps=50' \
+  -F 'flow_shift=12' \
+  -F 'seed=1101' \
+  -F 'extra_params={"task":"t2va","duration":5.0,"audio_flow_shift":3.0}' \
+  -o t2va.mp4
+```

recipes/NVIDIA/NemotronLabs-VoiceChat.md

@@ -0,0 +1,113 @@
+# NemotronLabs VoiceChat 11B
+
+> 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
+
+- Vendor: NVIDIA
+- Model: [`nvidia/NVIDIA-NemotronLabs-VoiceChat-11B`](https://huggingface.co/nvidia/NVIDIA-NemotronLabs-VoiceChat-11B)
+- Task: Speech-to-speech voice chat. The model runs a frame-locked 12.5 Hz
+  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). Online/duplex serving,
+  function calling, and batch>1 are documented follow-ups.
+- Maintainer: [`@yuekaizhang`](https://github.com/yuekaizhang)
+
+## When to use this recipe
+
+Use this recipe to run a single-turn voice-chat exchange with
+`NVIDIA-NemotronLabs-VoiceChat-11B` on one GPU: you provide a user utterance as
+a WAV file (any sample rate; it is resampled to 16 kHz mono) plus an optional
+spoken-style system prompt, and get back the agent's reply as text and a
+22.05 kHz WAV. The integration is NeMo-free at runtime — the perception
+Conformer, EAR-TTS talker, and RVQ-VAE codec are vendored, dependency-stripped
+NeMo modules (`nemo_vendored/`), so no `nemo_toolkit` install is needed.
+
+## References
+
+- Offline example:
+  [`examples/offline_inference/nemotron_voicechat/end2end.py`](../../examples/offline_inference/nemotron_voicechat/end2end.py)
+- Model modules (thinker / talker / code2wav / vendored NeMo):
+  [`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)
+- 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`
+
+## Pipeline
+
+| stage | arch | dtype | role |
+|---|---|---|---|
+| 0 thinker | `NemotronVoiceChatThinkerForConditionalGeneration` (LLM_AR) | fp32 | WAV + system prompt -> frame-locked text-token timeline (+ function channel) |
+| 1 talker | `NemotronVoiceChatTalker` (LLM_AR) | fp32 | text timeline -> 31-quantizer RVQ code stacks (one per 80 ms frame) |
+| 2 code2wav | `NemotronVoiceChatCode2Wav` (LLM_GENERATION) | fp32 | RVQ-VAE decode -> 22.05 kHz PCM |
+
+Stages 0/1 default to fp32 for exact parity with the NeMo reference
+implementation (greedy decoding matches it token for token on the acceptance
+fixture). The deploy yaml documents a ~2x-faster bf16 thinker option whose
+output stayed within one word of the reference in testing.
+
+## Hardware Support
+
+## GPU
+
+### 1x H100 80GB
+
+#### Environment
+
+- OS: Linux
+- Python: 3.12
+- vLLM version: 0.26.0
+- vLLM-Omni version or commit: this PR / current `main`
+
+#### Command
+
+```bash
+# Tokenizer: the checkpoint ships no HF tokenizer; it resolves from the
+# nvidia/NVIDIA-Nemotron-Nano-9B-v2 HF id automatically. For air-gapped runs,
+# point NEMOTRON_VOICECHAT_LLM_PATH at a local snapshot of that repo instead.
+python examples/offline_inference/nemotron_voicechat/end2end.py \
+    --checkpoint /path/to/NVIDIA-NemotronLabs-VoiceChat-11B \
+    --wav /path/to/user_question.wav \
+    --output-dir results/nemotron_voicechat
+```
+
+#### Verification
+
+```bash
+ls results/nemotron_voicechat
+# <stem>_output.txt          the agent reply as text
+# <stem>_output.wav          the agent reply as 22.05 kHz audio
+# <stem>_text_tokens.json    the frame-locked text-token timeline
+```
+
+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.
+
+#### Notes
+
+- Memory usage: the shipped yaml runs all three stages on one GPU
+  (`gpu_memory_utilization` 0.62 / 0.12 / 0.06); peak usage is dominated by the
+  fp32 thinker. The fp32 default has a hard floor of roughly 43 GB of thinker
+  weights alone (9B backbone + 587M `embed_tokens` + 587M `function_head` +
+  0.6B Conformer), so 48 GB cards cannot run it — use the bf16 thinker option
+  documented in the deploy yaml on anything smaller than an 80 GB part.
+- Input sizing: the timeline is frame-locked, so the reply budget IS the input
+  duration. The acoustic channel trails the text channel; if the WAV does not
+  carry enough trailing silence for the reply to finish, the spoken answer is
+  truncated silently. Leave generous trailing silence (a question ending at
+  ~4.5 s truncated in an 8 s WAV but completed cleanly in 16 s); the offline
+  example warns when the text channel is still speaking near the last frame.
+- Key flags: sampling is greedy end to end. The thinker is frame-locked —
+  `max_tokens` equals the acoustic frame count with `ignore_eos=True`. Do NOT
+  set `min_tokens` on the thinker: the tokenizer's EOS token is also the
+  frame-locked PAD/silence token, so masking it forces the model to babble
+  instead of pausing.
+- The talker's `max_tokens` is 16383 (its stage prompt is one placeholder
+  token, and the stage context is 16384).
+- Known limitations: batch=1 only; offline single turn (no online/duplex
+  serving yet); the function-call channel is decoded but not yet acted on.

recipes/README.md

@@ -50,6 +50,7 @@ recipes/
 | [`inclusionAI/Ming-flash-omni-2.0.md`](./inclusionAI/Ming-flash-omni-2.0.md) | Online serving for multimodal chat + standalone TTS | 4x H100 / 1x H100 80GB |
 | [`inclusionAI/Ming-omni-tts.md`](./inclusionAI/Ming-omni-tts.md) | Offline + online dense Ming TTS/audio generation | 1x H100 80GB / 1x AMD MI300X (ROCm 7.2) |
 | [`IndexTeam/IndexTTS-2.md`](./IndexTeam/IndexTTS-2.md) | Online serving for voice-cloned TTS with optional emotion control | 1x L4 24GB or larger CUDA GPU |
+| [`IndexTeam/IndexTTS-2_5.md`](./IndexTeam/IndexTTS-2_5.md) | Online + offline multilingual voice-cloned TTS with native speed and emotion control | 1x NVIDIA H20 96GB |
 | [`MiniMaxAI/MiniMax-H3.md`](./MiniMaxAI/MiniMax-H3.md) | T2VA, FL2VA, image+audio Ref2VA, and multi-video Ref2VA serving | 1x GPU with CPU offload / 4x B300 |
 | [`MiniMaxAI/MiniMax-H3-MUSA.md`](./MiniMaxAI/MiniMax-H3-MUSA.md) | MiniMax H3 T2VA, FL2VA, and Ref2VA on MUSA | 4x MTT S5000 (TP4 Ref2VA profile) |
 | [`krea/Krea-2.md`](./krea/Krea-2.md) | Text-to-image (Turbo + Raw), offline + online, with LoRA | 1x H100 80GB |
@@ -65,6 +66,7 @@ recipes/
 | [`OpenBMB/VoxCPM2.md`](./OpenBMB/VoxCPM2.md) | Online + offline TTS with native AR pipeline (48 kHz, 30+ languages) | 1x RTX 4090 24GB |
 | [`OpenMOSS/MOSS-TTS.md`](./OpenMOSS/MOSS-TTS.md) | Online + offline multilingual TTS (MOSS-TTS family, 8B) | 1x H100 80GB |
 | [`NVIDIA/Nemotron-Labs-Audex.md`](./NVIDIA/Nemotron-Labs-Audex.md) | TTS / text-to-audio / audio understanding / cascaded S2S (Audex 2B + 30B-A3B) | 1x H100 80GB |
+| [`NVIDIA/NemotronLabs-VoiceChat.md`](./NVIDIA/NemotronLabs-VoiceChat.md) | Offline speech-to-speech voice chat (11B, frame-locked 12.5 Hz, 3-stage thinker/talker/code2wav) | 1x H100 80GB |
 | [`Qwen/Qwen-Image.md`](./Qwen/Qwen-Image.md) | Text-to-image serving with step-wise continuous batching replay and ModelOpt mixed FP8/NVFP4 | 1x A100 80GB / 2x B200 |
 | [`Qwen/Qwen-Image-2512.md`](./Qwen/Qwen-Image-2512.md) | Text-to-image serving with step-wise continuous batching replay and ModelOpt FP8 / mixed FP8/NVFP4 | 1x A800 80GB / 2x B200 |
 | [`Qwen/Qwen-Image-Edit.md`](./Qwen/Qwen-Image-Edit.md) | Text-guided single-image editing | 1x or 2x H200 141GB |

tests/benchmarks/test_bench_tts_cli.py

@@ -51,6 +51,14 @@ def test_load_model_configs(model_configs_path: Path) -> None:
     assert configs["test/ModelA"]["supported_tasks"] == ["voice_clone", "default_voice"]
 
 
+def test_indextts25_is_registered_in_shared_model_configs() -> None:
+    config_path = Path(bench_tts.__file__).with_name("model_configs.yaml")
+    config = bench_tts.load_model_configs(config_path)["IndexTeam/IndexTTS-2.5"]
+
+    assert config["supported_tasks"] == ["voice_clone"]
+    assert config["task_extra_body"]["voice_clone"]["extra_params"]["lang"] == "en"
+
+
 def test_build_bench_args_voice_clone(model_configs_path: Path) -> None:
     configs = bench_tts.load_model_configs(model_configs_path)
     cmd = bench_tts.build_bench_args(
@@ -120,6 +128,34 @@ def test_build_bench_args_wer_eval_adds_flag(model_configs_path: Path) -> None:
     assert "--seed-tts-wer-eval" in cmd
 
 
+def test_build_bench_args_supports_local_model_and_shared_sweep_options(model_configs_path: Path) -> None:
+    configs = bench_tts.load_model_configs(model_configs_path)
+    cmd = bench_tts.build_bench_args(
+        host="localhost",
+        port=8092,
+        model="test/ModelA",
+        served_model_name="/models/indextts25",
+        task="voice_clone",
+        model_cfg=configs["test/ModelA"],
+        locale="en",
+        num_prompts=500,
+        num_warmups=5,
+        request_seed=42,
+        concurrency=8,
+        dataset_path="/data/seed-tts",
+        wer_eval=False,
+        output_dir=None,
+        result_filename=None,
+        extra_cli_args=["--", "--tokenizer", "/models/indextts25/qwen0.6bemo4-merge"],
+    )
+
+    assert cmd[cmd.index("--model") + 1] == "/models/indextts25"
+    assert cmd[cmd.index("--num-warmups") + 1] == "5"
+    assert cmd[-2:] == ["--tokenizer", "/models/indextts25/qwen0.6bemo4-merge"]
+    extra_body = json.loads(cmd[cmd.index("--extra-body") + 1])
+    assert extra_body == {"task_type": "Base", "seed": 42}
+
+
 def test_unsupported_task_exits(model_configs_path: Path, capsys: pytest.CaptureFixture, mocker) -> None:
     # ModelB does not support voice_design
     mocker.patch.object(

tests/benchmarks/test_daily_omni_local_source.py

@@ -0,0 +1,92 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Offline Daily-Omni sources: local mirrors must not fall back to the Hub id."""
+
+import json
+import os
+import tarfile
+from pathlib import Path
+
+import pytest
+
+from vllm_omni.benchmarks.data_modules.daily_omni_dataset import (
+    daily_omni_local_qa_json,
+    daily_omni_local_videos_dir,
+    resolve_daily_omni_local_root,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.benchmark]
+
+
+def _write_qa_json(root: Path) -> Path:
+    qa = root / "qa.json"
+    qa.write_text(json.dumps([{"Question": "q", "Answer": "A", "video_id": "vid0"}]), encoding="utf-8")
+    return qa
+
+
+def test_resolve_local_root_returns_none_for_hub_id() -> None:
+    assert resolve_daily_omni_local_root("liarliar/Daily-Omni") is None
+    assert resolve_daily_omni_local_root("") is None
+    assert resolve_daily_omni_local_root(None) is None
+
+
+def test_plain_local_mirror(tmp_path: Path) -> None:
+    _write_qa_json(tmp_path)
+    (tmp_path / "Videos" / "vid0").mkdir(parents=True)
+
+    root = resolve_daily_omni_local_root(str(tmp_path))
+    assert root == tmp_path.resolve()
+    assert daily_omni_local_qa_json(root) == (tmp_path / "qa.json").resolve()
+    assert daily_omni_local_videos_dir(root) == root / "Videos"
+
+
+def test_hf_cache_dir_resolves_to_snapshot(tmp_path: Path) -> None:
+    cache_dir = tmp_path / "datasets--liarliar--Daily-Omni"
+    snapshot = cache_dir / "snapshots" / "deadbeef"
+    snapshot.mkdir(parents=True)
+    _write_qa_json(snapshot)
+    (cache_dir / "refs").mkdir()
+    (cache_dir / "refs" / "main").write_text("deadbeef", encoding="utf-8")
+
+    root = resolve_daily_omni_local_root(str(cache_dir))
+    assert root == snapshot.resolve()
+    assert daily_omni_local_qa_json(root) == (snapshot / "qa.json").resolve()
+
+
+def test_hf_cache_dir_without_refs_picks_newest_snapshot(tmp_path: Path) -> None:
+    cache_dir = tmp_path / "datasets--liarliar--Daily-Omni"
+    older = cache_dir / "snapshots" / "aaa"
+    newer = cache_dir / "snapshots" / "bbb"
+    older.mkdir(parents=True)
+    newer.mkdir(parents=True)
+    os.utime(older, (1, 1))
+    os.utime(newer, (10, 10))
+
+    assert resolve_daily_omni_local_root(str(cache_dir)) == newer.resolve()
+
+
+def test_videos_tar_is_extracted(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("HF_HOME", str(tmp_path / "hf_home"))
+    root = tmp_path / "mirror"
+    (root / "Videos" / "vid0").mkdir(parents=True)
+    (root / "Videos" / "vid0" / "vid0_video.mp4").write_bytes(b"fake")
+    with tarfile.open(root / "Videos.tar", "w") as tf:
+        tf.add(root / "Videos", arcname="Videos")
+    # Only the tarball is left in the mirror.
+    for child in (root / "Videos").rglob("*"):
+        if child.is_file():
+            child.unlink()
+    (root / "Videos" / "vid0").rmdir()
+    (root / "Videos").rmdir()
+
+    videos_dir = daily_omni_local_videos_dir(root)
+    assert videos_dir is not None
+    assert (videos_dir / "vid0" / "vid0_video.mp4").is_file()
+
+    # Second call reuses the extraction instead of redoing it.
+    assert daily_omni_local_videos_dir(root) == videos_dir
+
+
+def test_missing_qa_json_reports_none(tmp_path: Path) -> None:
+    root = resolve_daily_omni_local_root(str(tmp_path))
+    assert daily_omni_local_qa_json(root) is None
+    assert daily_omni_local_videos_dir(root) is None

tests/benchmarks/test_daily_omni_pack_modes.py

@@ -2,9 +2,8 @@
 
 The ``minicpm-interleave`` mode is an accuracy-critical protocol: MiniCPM-o only reaches
 OpenBMB's reported Daily-Omni score when frames and 1s audio segments arrive strictly
-interleaved, with ``max_slice_nums=1`` / ``use_image_id=False`` and an empty MiniCPM
-system message (not the Qwen system prompt). These tests pin that contract so a refactor
-cannot silently regress the score.
+interleaved, with ``max_slice_nums=1`` / ``use_image_id=False`` and no Qwen system prompt.
+These tests pin that contract so a refactor cannot silently regress the score.
 
 vllm stubs are installed by tests/benchmarks/conftest.py before collection.
 """
@@ -99,22 +98,13 @@ def _stub_extract(monkeypatch, dataset: DailyOmniDataset, counter: list[int]) ->
 # ---------------------------------------------------------------------------
 
 
-@pytest.mark.parametrize(("n", "k"), [(10, 4), (100, 64), (1000, 64), (7, 7), (3, 5), (1, 1)])
-def test_uniform_sample_indices_matches_openbmb_midpoint(n: int, k: int) -> None:
-    """Pin OpenBMB midpoint-bin sampling (not np.linspace endpoints)."""
+@pytest.mark.parametrize(("n", "k"), [(10, 4), (100, 64), (7, 7), (3, 5), (1, 1)])
+def test_uniform_sample_indices_matches_numpy_linspace(n: int, k: int) -> None:
     got = _uniform_sample_indices(n, k)
     if n <= k:
         assert got == list(range(n))
     else:
-        gap = n / k
-        expected = [int(i * gap + gap / 2) for i in range(k)]
-        assert got == expected
-        # Endpoints differ from linspace for typical Daily-Omni downsample sizes.
-        linspace = [int(i) for i in np.linspace(0, n - 1, k, dtype=int)]
-        if n == 1000 and k == 64:
-            assert got[0] == 7 and got[-1] == 992
-            assert linspace[0] == 0 and linspace[-1] == 999
-            assert got != linspace
+        assert got == [int(i) for i in np.linspace(0, n - 1, k, dtype=int)]
 
 
 def test_uniform_sample_indices_non_positive_k() -> None:
@@ -223,16 +213,14 @@ def test_minicpm_interleave_missing_local_video_returns_none(qa_json, tmp_path)
 # ---------------------------------------------------------------------------
 
 
-def test_minicpm_interleave_keeps_empty_system_message(monkeypatch, qa_json, video_dir) -> None:
-    """Official MiniCPM omni mode still sends role=system with empty content."""
+def test_minicpm_interleave_omits_qwen_system_message(monkeypatch, qa_json, video_dir) -> None:
     ds = _make_dataset(qa_json, video_dir, pack_mode="minicpm-interleave", input_mode="all")
     _stub_extract(monkeypatch, ds, [])
     parts, _extra, _position = ds._compose_daily_omni_multimodal(_VIDEO_ID, None)
 
     messages = ds._build_daily_omni_openai_messages(parts, "q?", {"A": "a"})
 
-    assert [m["role"] for m in messages] == ["system", "user"]
-    assert messages[0]["content"][0]["text"] == ""
+    assert [m["role"] for m in messages] == ["user"]
 
 
 def test_qwen_pack_mode_keeps_system_message(qa_json, video_dir) -> None:

tests/config/test_config_factory.py

@@ -2206,6 +2206,24 @@ class TestBaseConfigInheritance:
 class TestPlatformOverrides:
     """Test platform-specific deploy config overrides."""
 
+    def test_qwen3_omni_musa_clears_parent_quantization_for_audio_stages(self):
+        pipeline = resolve_pipeline_config(
+            "qwen3_omni_moe",
+            Q3_OMNI_ALL_STAGES_HF_CONFIG,
+        )
+        assert isinstance(pipeline, PipelineConfig)
+        deploy_path = Path(get_deploy_config_path("qwen3_omni_moe.yaml"))
+
+        base_stages = merge_pipeline_deploy(pipeline, load_deploy_config(deploy_path))
+        assert "hf_overrides" not in base_stages[1].yaml_engine_args
+        assert "hf_overrides" not in base_stages[2].yaml_engine_args
+
+        musa = _apply_platform_overrides(load_deploy_config(deploy_path), platform="musa")
+        musa_stages = merge_pipeline_deploy(pipeline, musa)
+        expected = {"quantization_config": None}
+        assert musa_stages[1].yaml_engine_args["hf_overrides"] == expected
+        assert musa_stages[2].yaml_engine_args["hf_overrides"] == expected
+
     def test_qwen3_tts_rocm_disables_code2wav_outer_cudagraph(self):
         deploy_path = Path(get_deploy_config_path("qwen3_tts.yaml"))
 
@@ -2258,6 +2276,16 @@ class TestPlatformOverrides:
         # Stage 2 unaffected fields stay at base
         assert deploy.stages[2].enforce_eager is False
 
+    def test_qwen2_5_omni_xpu_uses_eager_ar_stages(self):
+        deploy_path = Path(get_deploy_config_path("qwen2_5_omni.yaml"))
+
+        deploy = load_deploy_config(deploy_path)
+        deploy = _apply_platform_overrides(deploy, platform="xpu")
+
+        assert deploy.stages[0].enforce_eager is True
+        assert deploy.stages[1].enforce_eager is True
+        assert deploy.stages[2].enforce_eager is True
+
     def test_xpu_overrides(self):
         deploy_path = Path(get_deploy_config_path("qwen3_omni_moe.yaml"))
         if not deploy_path.exists():

tests/config/test_forced_aligner_injection.py

@@ -0,0 +1,71 @@
+import pytest
+
+import vllm_omni.config.pipeline_registry  # noqa: F401  (populate registry)
+from vllm_omni.config.pipeline_registry import OMNI_PIPELINES as _PIPELINE_REGISTRY
+from vllm_omni.config.stage_config import (
+    DeployConfig,
+    StageExecutionType,
+)
+from vllm_omni.model_executor.stage_input_processors.forced_aligner import (
+    POOLING_OUTPUT_DECODER_PATH,
+    TIMESTAMPS_MODALITY,
+)
+from vllm_omni.utils.forced_aligner import _DEFAULT_CONFIG_PATH, inject_forced_aligner_stage
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_inject_appends_pooling_aligner_stage():
+    pipeline = _PIPELINE_REGISTRY["qwen3_tts"]
+    deploy = DeployConfig()
+    n0 = len(pipeline.stages)
+
+    ext_pipeline, ext_deploy = inject_forced_aligner_stage(
+        pipeline, deploy, {"forced_aligner": "/models/Qwen3-ForcedAligner-0.6B"}
+    )
+
+    # A new pooling stage is appended; the original pipeline is unchanged.
+    assert len(pipeline.stages) == n0
+    assert len(ext_pipeline.stages) == n0 + 1
+    # The original deploy config is not mutated either (double-injection safe).
+    assert len(deploy.stages) == 0
+    assert len(ext_deploy.stages) == 1
+    aligner = ext_pipeline.stages[-1]
+    # Pooling stage reuses LLM_AR (+ runner=pooling), no dedicated LLM_POOLING.
+    assert aligner.execution_type == StageExecutionType.LLM_AR
+    assert aligner.final_output is True
+    assert aligner.final_output_type == TIMESTAMPS_MODALITY
+    assert aligner.input_sources == (n0 - 1,)
+    assert aligner.requires_multimodal_data is True
+    assert aligner.owns_tokenizer is True
+
+    # The deploy stage carries the separate aligner checkpoint + decoder hook.
+    ds = ext_deploy.stages[-1]
+    assert ds.engine_extras["model"] == "/models/Qwen3-ForcedAligner-0.6B"
+    assert ds.engine_extras["runner"] == "pooling"
+    assert ds.engine_extras["pooling_output_decoder"] == POOLING_OUTPUT_DECODER_PATH
+
+
+def test_inject_from_config_only():
+    # --forced-aligner-config alone (model in the YAML) must also inject.
+    pipeline = _PIPELINE_REGISTRY["qwen3_tts"]
+    deploy = DeployConfig()
+    n0 = len(pipeline.stages)
+
+    ext_pipeline, ext_deploy = inject_forced_aligner_stage(
+        pipeline, deploy, {"forced_aligner": None, "forced_aligner_config": str(_DEFAULT_CONFIG_PATH)}
+    )
+
+    assert len(ext_pipeline.stages) == n0 + 1
+    assert ext_pipeline.stages[-1].final_output_type == TIMESTAMPS_MODALITY
+    assert ext_deploy.stages[-1].engine_extras["model"] == "Qwen/Qwen3-ForcedAligner-0.6B"
+
+
+def test_inject_noop_without_forced_aligner():
+    pipeline = _PIPELINE_REGISTRY["qwen3_tts"]
+    deploy = DeployConfig()
+
+    ext_pipeline, ext_deploy = inject_forced_aligner_stage(pipeline, deploy, {})
+
+    assert ext_pipeline is pipeline
+    assert len(ext_deploy.stages) == 0

tests/config/test_omni_config.py

@@ -513,6 +513,7 @@ def test_sub_config_fields_match_structured_scopes():
         "enable_prefix_caching",
         "disable_hybrid_kv_cache_manager",
         "mm_processor_cache_gb",
+        "mamba_ssm_cache_dtype",
     }
     assert {f.name for f in fields(OmniStageSchedulerConfig)} == {
         "max_num_seqs",
@@ -778,6 +779,26 @@ def test_structured_diffusion_config_rejects_non_boolean_compile_dynamic():
         omni_config_module._DiffusionConfigProjection(diffusion_compile_dynamic="false")
 
 
+def test_from_pipeline_config_routes_ltx2_model_extra(tmp_path):
+    deploy_path = tmp_path / "dreamzero_ltx2_extras.yaml"
+    deploy_path.write_text(
+        "\n".join(
+            [
+                "pipeline: dreamzero",
+                "async_chunk: false",
+                "stages:",
+                "  - stage_id: 0",
+                "    extras:",
+                "      ltx2_use_channels_last_3d: true",
+            ]
+        )
+    )
+
+    stage = _from_pipeline_key("dreamzero", deploy_config_path=str(deploy_path)).stage_by_id(0)
+
+    assert stage.diffusion_config.extras["ltx2_use_channels_last_3d"] is True
+
+
 def test_structured_diffusion_config_rejects_invalid_compile_granularity():
     with pytest.raises(ValidationError, match="diffusion_compile_granularity"):
         omni_config_module._DiffusionConfigProjection(diffusion_compile_granularity="block")

tests/core/sched/test_omni_ar_scheduler_logprobs.py

@@ -27,6 +27,7 @@ _MIXIN_UPDATE_HELPERS = (
     "_attach_finished_request_sets",
     "_attach_scheduler_stats",
     "_capture_omni_connector_output",
+    "_maybe_decode_pooling_output",
 )
 
 
@@ -92,6 +93,9 @@ class _Request:
         self.num_computed_tokens = 0
         self.num_in_flight_tokens = 0
         self.num_output_placeholders = 0
+        # vLLM 0.27 (a0c092ee72): Request gained num_stale_output_tokens to
+        # track in-flight outputs discarded at preemption/streaming-stop.
+        self.num_stale_output_tokens = 0
         self.has_encoder_inputs = False
         self.pooling_params = None
         self.resumable = True
@@ -135,6 +139,7 @@ def _make_scheduler_stub(requests: list[_Request]) -> SimpleNamespace:
         pending_stop_after_extraction=set(),
         waiting_for_transfer_free=set(),
         _new_prompt_len_snapshot={},
+        _pooling_output_decoder=None,
         finished_req_ids=set(),
         finished_req_ids_dict=defaultdict(set),
         kv_cache_manager=SimpleNamespace(take_events=lambda: None),
@@ -264,3 +269,72 @@ def test_invalid_logprobs_finish_only_the_affected_scheduler_request() -> None:
     assert output_by_id["bad"].new_token_ids == []
     assert output_by_id["good"].new_token_ids == [8]
     np.testing.assert_array_equal(output_by_id["good"].new_logprobs.logprob_token_ids[:, 0], [8])
+
+
+def _pooling_model_runner_output(pooler_tensor) -> SimpleNamespace:
+    return SimpleNamespace(
+        sampled_token_ids=[[]],
+        logprobs=None,
+        prompt_logprobs_dict={},
+        pooler_output=[pooler_tensor],
+        num_nans_in_logits=None,
+        kv_connector_output=None,
+        cudagraph_stats=None,
+        req_id_to_index={"req": 0},
+        routed_experts=None,
+    )
+
+
+def _make_pooling_stub(decoder) -> tuple[_Request, SimpleNamespace]:
+    request = _Request("req")
+    request.sampling_params = SimpleNamespace(num_logprobs=None)
+    request.pooling_params = SimpleNamespace()
+    scheduler = _make_scheduler_stub([request])
+    scheduler._pooling_output_decoder = decoder
+    scheduler.vllm_config = SimpleNamespace(model_config=SimpleNamespace(hf_config=None))
+    _bind_request_lifecycle(scheduler, update_request=lambda req, tokens: (tokens, False))
+    return request, scheduler
+
+
+def test_pooling_decode_success_emits_decoded_payload() -> None:
+    import torch
+
+    decoded = torch.tensor([[1, 2]], dtype=torch.int32)
+    request, scheduler = _make_pooling_stub(lambda logits, req, hf: decoded)
+
+    scheduler_output = SimpleNamespace(
+        num_scheduled_tokens={"req": 1},
+        scheduled_spec_decode_tokens={},
+        num_invalid_spec_tokens=0,
+    )
+    outputs = OmniARScheduler.update_from_output(
+        scheduler, scheduler_output, _pooling_model_runner_output(torch.zeros(2, 4))
+    )
+    (output,) = outputs[0].outputs
+
+    assert output.finish_reason is FinishReason.STOP
+    assert output.pooling_output is decoded
+
+
+def test_pooling_decode_failure_finishes_request_with_error() -> None:
+    import torch
+
+    def raising_decoder(logits, req, hf):
+        raise ValueError("boom")
+
+    request, scheduler = _make_pooling_stub(raising_decoder)
+
+    scheduler_output = SimpleNamespace(
+        num_scheduled_tokens={"req": 1},
+        scheduled_spec_decode_tokens={},
+        num_invalid_spec_tokens=0,
+    )
+    outputs = OmniARScheduler.update_from_output(
+        scheduler, scheduler_output, _pooling_model_runner_output(torch.zeros(2, 4))
+    )
+    (output,) = outputs[0].outputs
+
+    # Decoder failure is a request error (500), not an empty success.
+    assert output.finish_reason is FinishReason.ERROR
+    assert output.pooling_output is None
+    assert "pooling output decode failed" in str(request.stop_reason)

tests/core/sched/test_omni_ar_scheduler_stale_drain.py

@@ -0,0 +1,223 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Investigation tests for the num_stale_output_tokens drain (59b9e719).
+
+The seed-TTS WER regression appeared with the vLLM 0.27 rebase (nightly
+2946 -> 2949: mean WER 0.2695 -> 0.3936, median 0.0 in both), whose prime
+suspect is the reimplemented async-token discard: vLLM 0.26 drained
+``async_tokens_to_discard`` one arriving frame at a time and suppressed
+only the token append; the 0.27 adaptation seeds
+``num_stale_output_tokens`` with the discarded *placeholder count* and
+drains it by each arriving frame's ``num_tokens_scheduled``, dropping the
+whole per-request update. Whenever seed and arrivals disagree, the counter
+outlives the old segment and the drain consumes *valid* frames of the new
+segment — a hole in the talker's codec stream (garbled audio, text/audio
+mismatch) — or underflows its own assert on the new segment's prefill
+frame (engine-core death mid-step).
+
+The fix seeds the counter from ``num_in_flight_tokens`` — the same
+scheduled-token units the drain subtracts — so every pre-discard frame
+drains exactly its own contribution and new-segment frames can never be
+swallowed. These tests pin that contract one frame at a time; the
+delivered / swallowed observable is whether ``_update_request_with_output``
+runs for the frame.
+"""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+import pytest
+
+# Imports must run in this order: vllm_omni applies patches to vllm.v1.request
+# before Request / StreamingUpdate 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, StreamingUpdate
+from vllm_omni.core.sched.omni_ar_scheduler import OmniARScheduler
+
+# isort: on
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _make_session() -> Request:
+    session = Request(
+        request_id="req-stale-drain-test",
+        prompt_token_ids=[1, 2, 3],
+        sampling_params=SamplingParams(max_tokens=32),
+        pooling_params=None,
+        arrival_time=100.0,
+        block_hasher=None,
+    )
+    session.status = RequestStatus.RUNNING
+    if not hasattr(session, "num_stale_output_tokens"):
+        # vLLM 0.27 defines this Request field; 0.26 (local dev) does not.
+        session.num_stale_output_tokens = 0
+    if not hasattr(session, "num_in_flight_tokens"):
+        session.num_in_flight_tokens = 0
+    return session
+
+
+def _replace_streaming_session(session: Request) -> None:
+    """Run the real stage-0 streaming replacement (the discard/seed site)."""
+    sched = OmniARScheduler.__new__(OmniARScheduler)
+    sched._new_prompt_len_snapshot = {}
+    sched.vllm_config = SimpleNamespace(model_config=SimpleNamespace(stage_id=0))
+    sched.num_waiting_for_streaming_input = 0
+    sched.log_stats = False
+    sched.chunk_transfer_adapter = None
+    sched.skipped_waiting = set()
+    session.status = RequestStatus.WAITING_FOR_STREAMING_REQ
+    update = StreamingUpdate(
+        mm_features=None,
+        prompt_token_ids=[10, 20],
+        max_tokens=32,
+        arrival_time=200.0,
+        sampling_params=SamplingParams(max_tokens=16),
+    )
+    sched._update_request_as_session(session, update)
+    session.status = RequestStatus.RUNNING
+
+
+def _make_drain_sched(session: Request) -> MagicMock:
+    sched = MagicMock()
+    sched.requests = {session.request_id: session}
+    sched.perf_metrics = None
+    sched.structured_output_manager.should_advance.return_value = False
+    sched._update_request_with_output.return_value = ([42], False)
+    sched._process_kv_transfer_trigger.return_value = False
+    sched.chunk_transfer_adapter = MagicMock()
+    sched.running = [session]
+    sched.waiting_for_transfer_free = set()
+    sched.transfer_triggered_requests = set()
+    sched.active_kv_transfers = set()
+    sched.pending_stop_after_extraction = set()
+    sched.connector = None
+    sched.kv_cache_manager.take_events.return_value = None
+    sched.finished_req_ids_dict = {}
+    sched.make_stats.return_value = None
+    return sched
+
+
+def _run_step(sched: MagicMock, session: Request, *, num_scheduled: int, token: int) -> bool:
+    """Feed one model-runner frame through update_from_output.
+
+    Returns True when the frame's tokens were delivered (the append ran),
+    False when the frame was swallowed by the stale drain.
+    """
+    scheduler_output = MagicMock(spec=SchedulerOutput)
+    scheduler_output.num_scheduled_tokens = {session.request_id: num_scheduled}
+    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 = [[token]]
+    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 = {session.request_id: 0}
+    model_runner_output.routed_experts = None
+    model_runner_output.inter_stage_outputs = None
+
+    sched._update_request_with_output.reset_mock()
+    OmniARScheduler.update_from_output(sched, scheduler_output, model_runner_output)
+    return sched._update_request_with_output.called
+
+
+def test_exact_drain_delivers_new_segment_frame() -> None:
+    """One in-flight decode frame at replacement: its late output drains the
+    counter exactly and the new segment's first frame is delivered."""
+    session = _make_session()
+    session.append_output_token_ids([7, 8, 9])
+    session.num_computed_tokens = 6
+    session.num_output_placeholders = 1
+    session.num_in_flight_tokens = 1
+
+    _replace_streaming_session(session)
+    assert session.num_stale_output_tokens == 1
+
+    sched = _make_drain_sched(session)
+    assert _run_step(sched, session, num_scheduled=1, token=42) is False  # late frame dropped
+    assert session.num_stale_output_tokens == 0
+    assert _run_step(sched, session, num_scheduled=1, token=43) is True  # new segment survives
+
+
+def test_two_in_flight_frames_drain_without_swallowing() -> None:
+    """Two in-flight decode frames: both late frames drop, the new segment's
+    first valid frame is delivered. A placeholder-based seed swallowed it
+    whenever fewer frames arrived than placeholders counted (the driver of
+    the seed-TTS WER regression, nightly 2946 -> 2949: 0.2695 -> 0.3936)."""
+    session = _make_session()
+    session.append_output_token_ids([7, 8, 9])
+    session.num_computed_tokens = 7
+    session.num_output_placeholders = 2
+    session.num_in_flight_tokens = 2
+
+    _replace_streaming_session(session)
+    assert session.num_stale_output_tokens == 2
+
+    sched = _make_drain_sched(session)
+    assert _run_step(sched, session, num_scheduled=1, token=42) is False  # late frame 1
+    assert _run_step(sched, session, num_scheduled=1, token=44) is False  # late frame 2
+    assert session.num_stale_output_tokens == 0
+
+    delivered = _run_step(sched, session, num_scheduled=1, token=43)  # new segment, frame 1
+    assert delivered is True, (
+        "valid new-segment frame was swallowed by leftover stale count "
+        f"(num_stale_output_tokens left at {session.num_stale_output_tokens})"
+    )
+
+
+def test_spec_placeholder_asymmetry_does_not_swallow_valid_frame() -> None:
+    """Placeholder counts can exceed scheduled counts (e.g. a draft
+    invalidated before execution): 1 in-flight MTP frame scheduled 2 tokens
+    but contributed 3 placeholders. Seeding from num_in_flight_tokens keeps
+    seed == drain, so the new segment's valid frame is delivered."""
+    session = _make_session()
+    session.append_output_token_ids([7])
+    session.num_computed_tokens = 7
+    session.num_output_placeholders = 3  # 1 sampled + 2 spec placeholders
+    session.num_in_flight_tokens = 2  # the frame actually scheduled 1 + 1 tokens
+
+    _replace_streaming_session(session)
+    assert session.num_stale_output_tokens == 2
+
+    sched = _make_drain_sched(session)
+    assert _run_step(sched, session, num_scheduled=2, token=42) is False  # late MTP frame
+    assert session.num_stale_output_tokens == 0
+    delivered = _run_step(sched, session, num_scheduled=1, token=43)  # new segment, frame 1
+    assert delivered is True, (
+        "valid new-segment frame swallowed after spec placeholder asymmetry "
+        f"(num_stale_output_tokens left at {session.num_stale_output_tokens})"
+    )
+
+
+def test_in_flight_prefill_chunk_drains_exactly_without_underflow() -> None:
+    """An in-flight prefill chunk carries no placeholders but 5 scheduled
+    tokens. The placeholder-based seed missed it entirely (its late output
+    was appended to the rolled-back session) and any leftover counter
+    underflowed 'assert num_stale_output_tokens >= 0' on the chunk's arrival,
+    killing the engine-core step. Seeding from num_in_flight_tokens drops the
+    late chunk and drains to exactly zero."""
+    session = _make_session()
+    session.append_output_token_ids([7, 8, 9])
+    session.num_computed_tokens = 7
+    session.num_output_placeholders = 0  # prefill chunk: no placeholders
+    session.num_in_flight_tokens = 5  # the chunk's scheduled tokens
+
+    _replace_streaming_session(session)
+    assert session.num_stale_output_tokens == 5
+
+    sched = _make_drain_sched(session)
+    assert _run_step(sched, session, num_scheduled=5, token=42) is False  # late prefill chunk dropped
+    assert session.num_stale_output_tokens == 0
+    assert _run_step(sched, session, num_scheduled=1, token=43) is True  # new segment survives

tests/core/sched/test_omni_scheduling_coordinator.py

@@ -120,12 +120,16 @@ class TestFullPayloadCoordinatorSelection(unittest.TestCase):
             ("MiMoAudioModel", "code2wav"),
             ("Qwen3TTSCode2Wav", "code2wav"),
             ("MiniCPMO45Code2Wav", "code2wav"),
+            # nemotron_voicechat: sync-path RVQ-VAE decode waits for the
+            # talker's full [frames, 31] code-stack payload.
+            ("NemotronVoiceChatCode2Wav", "code2wav"),
             ("CosyVoice3Model", "cosyvoice3_code2wav"),
             # audex: sync-path TTS decoder (async_chunk: false deploys) and
             # the TTA XCodec1 stage (always sync full-payload).
             ("AudexCode2Wav", "audex_code2wav"),
             ("AudexXCodec1", "audex_xcodec"),
             ("IndexTTS2S2MelDecoder", "indextts2_s2mel_decoder"),
+            ("IndexTTS25S2MelDecoder", "indextts2_5_s2mel_decoder"),
             ("DyninOmniForConditionalGeneration", "token2image"),
             ("DyninOmniForConditionalGeneration", "token2audio"),
         }

tests/dfx/perf/tests/test_minicpmo_4_5_ready.json

@@ -0,0 +1,80 @@
+[
+  {
+    "test_name": "test_minicpmo_4_5_ready",
+    "mark": [
+      {
+        "hardware_marks": {
+          "res": {
+            "cuda": "H100",
+            "npu": "A3"
+          },
+          "num_cards": 1
+        }
+      },
+      "core_model",
+      "omni"
+    ],
+    "server_params": {
+      "model": "openbmb/MiniCPM-o-4_5",
+      "extra_cli_args": [
+        "--deploy-config",
+        "vllm_omni/deploy/minicpmo_4_5.yaml",
+        "--trust-remote-code"
+      ]
+    },
+    "benchmark_params": [
+      {
+        "dataset_name": "seed-tts",
+        "dataset_path": "zhaochenyang20/seed-tts-eval",
+        "backend": "openai-chat-omni",
+        "endpoint": "/v1/chat/completions",
+        "num_prompts": [
+          10,
+          40
+        ],
+        "max_concurrency": [
+          1,
+          4
+        ],
+        "no_oversample": true,
+        "trust_remote_code": true,
+        "seed_tts_locale": "en",
+        "extra_body": {
+          "modalities": [
+            "text",
+            "audio"
+          ],
+          "chat_template_kwargs": {
+            "enable_thinking": false,
+            "use_tts_template": true
+          }
+        },
+        "percentile-metrics": "ttft,e2el,audio_ttfp,audio_rtf,audio_duration",
+        "baseline": {
+          "H100": {
+            "request_throughput": [
+              0.7803,
+              1.1008
+            ],
+            "mean_ttft_ms": [
+              166.9764,
+              307.7133
+            ],
+            "mean_e2el_ms": [
+              1361.1682,
+              3800.6332
+            ],
+            "mean_audio_ttfp_ms": [
+              635.8099,
+              1615.6591
+            ],
+            "mean_audio_rtf": [
+              0.3151,
+              0.8568
+            ]
+          }
+        }
+      }
+    ]
+  }
+]

tests/diffusion/batching/test_diffusion_batching.py

@@ -125,7 +125,7 @@ def _extract_images(output: OmniRequestOutput) -> list:
         return output.images
     # When the output comes from the orchestrator pipeline, images may be
     # nested inside request_output.
-    inner = getattr(output, "request_output", None)
+    inner = output
     if inner is not None and hasattr(inner, "images") and inner.images:
         return inner.images
     return []

tests/diffusion/cache/test_teacache.py

@@ -56,10 +56,10 @@ def test_teacache(model_name: str):
         # Extract images from request_output['images']
         first_output = outputs[0]
         assert first_output.final_output_type == "image"
-        if not hasattr(first_output, "request_output") or not first_output.request_output:
+        if not isinstance(first_output, OmniRequestOutput) or not first_output:
             raise ValueError("No request_output found in OmniRequestOutput")
 
-        req_out = first_output.request_output
+        req_out = first_output
         if not isinstance(req_out, OmniRequestOutput) or not hasattr(req_out, "images"):
             raise ValueError("Invalid request_output structure or missing 'images' key")
 

tests/diffusion/distributed/test_expert_parallel_layout.py

@@ -64,6 +64,7 @@ def test_moe_ep_maps_diffusion_sp_cfg_dp_to_vllm_groups(monkeypatch):
         local_rank,
         backend,
         group_name,
+        use_all2all=False,
     ):
         del backend
         group = _FakeGroup(
@@ -73,6 +74,7 @@ def test_moe_ep_maps_diffusion_sp_cfg_dp_to_vllm_groups(monkeypatch):
             device_communicator=object(),
             reduce_scatter=lambda tensor, **kwargs: tensor,
         )
+        group.use_all2all = use_all2all
         created_groups.append(group)
         return group
 
@@ -121,6 +123,9 @@ def test_moe_ep_maps_diffusion_sp_cfg_dp_to_vllm_groups(monkeypatch):
     assert parallel_state.vllm_parallel_state._PCP.device_communicator is not None
     assert parallel_state.vllm_parallel_state._DP.device_communicator is not None
     assert parallel_state.vllm_parallel_state._EP.device_communicator is not None
+    # vLLM 0.27's MoE oracle asserts the EP communicator has an all2all
+    # manager, which vLLM only builds for groups created with use_all2all.
+    assert parallel_state.vllm_parallel_state._EP.use_all2all is True
     assert hasattr(parallel_state.vllm_parallel_state._PCP, "reduce_scatter")
     assert hasattr(parallel_state.vllm_parallel_state._DP, "reduce_scatter")
     assert hasattr(parallel_state.vllm_parallel_state._EP, "reduce_scatter")
@@ -313,3 +318,35 @@ def test_non_moe_ep_fails_before_vllm_ep_remap(monkeypatch):
     assert parallel_state.vllm_parallel_state._PCP is None
     assert parallel_state.vllm_parallel_state._EP is None
     assert parallel_state._EXPERT_PARALLEL_GROUP_RANKS is None
+
+
+@pytest.mark.cpu
+@pytest.mark.core_model
+def test_init_vllm_group_forwards_use_all2all_only_when_supported(monkeypatch):
+    """use_all2all reaches vLLM only on versions whose API accepts it.
+
+    vLLM 0.27 builds the EP all2all manager only for groups created with
+    use_all2all=True (its MoE oracle then asserts the manager exists —
+    build 2953, HunyuanImage3-DIT accuracy). Older vLLM has no such kwarg,
+    so forwarding it unconditionally would TypeError at init.
+    """
+    received = {}
+
+    def modern(group_ranks, local_rank, backend, group_name=None, use_device_communicator=True, use_all2all=False):
+        received["modern"] = use_all2all
+        return object()
+
+    monkeypatch.setattr(parallel_state.vllm_parallel_state, "init_model_parallel_group", modern)
+    parallel_state.init_vllm_model_parallel_group([[0]], 0, "gloo", "ep", use_all2all=True)
+    assert received["modern"] is True
+
+    parallel_state.init_vllm_model_parallel_group([[0]], 0, "gloo", "tp")
+    assert received["modern"] is False
+
+    def legacy(group_ranks, local_rank, backend, group_name=None, use_device_communicator=True):
+        received["legacy"] = True
+        return object()
+
+    monkeypatch.setattr(parallel_state.vllm_parallel_state, "init_model_parallel_group", legacy)
+    parallel_state.init_vllm_model_parallel_group([[0]], 0, "gloo", "ep", use_all2all=True)
+    assert received["legacy"] is True

tests/diffusion/distributed/test_sequence_parallel.py

@@ -131,7 +131,7 @@ def _run_inference(
             elapsed_ms = (time.time() - start) * 1000
 
             return InferenceResult(
-                images=outputs[0].request_output.images,
+                images=outputs[0].images,
                 elapsed_ms=elapsed_ms,
             )
     finally:

tests/diffusion/distributed/test_tensor_parallel.py

@@ -49,10 +49,10 @@ def _diff_metrics(a: Image.Image, b: Image.Image) -> tuple[float, float]:
 def _extract_single_image(outputs) -> Image.Image:
     first_output = outputs[0]
     assert first_output.final_output_type == "image"
-    if not hasattr(first_output, "request_output") or not first_output.request_output:
+    if not isinstance(first_output, OmniRequestOutput) or not first_output:
         raise ValueError("No request_output found in OmniRequestOutput")
 
-    req_out = first_output.request_output
+    req_out = first_output
     if not isinstance(req_out, OmniRequestOutput) or not hasattr(req_out, "images"):
         raise ValueError("Invalid request_output structure or missing 'images' key")
 

tests/diffusion/distributed/test_wan_spatial_shard.py

@@ -231,6 +231,128 @@ def test_reshard_from_trimmed_width_pads_invalid_columns(monkeypatch: pytest.Mon
     assert torch.equal(out.flatten(), torch.tensor([4.0, 0.0]))
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
+@pytest.mark.parametrize("split_dim", ["height", "width"])
+@pytest.mark.parametrize(
+    ("full_extent", "world_size"),
+    [
+        pytest.param(5, 4, id="four-ranks-empty-tail"),
+        pytest.param(20, 8, id="production-eight-ranks-empty-tail"),
+        pytest.param(39, 2, id="two-ranks-partial-tail"),
+    ],
+)
+def test_reshard_from_trimmed_extent_clamps_and_reconstructs(
+    monkeypatch: pytest.MonkeyPatch,
+    split_dim: str,
+    full_extent: int,
+    world_size: int,
+):
+    local_extent = (full_extent + world_size - 1) // world_size
+    shape = (1, 1, 1, full_extent, 1) if split_dim == "height" else (1, 1, 1, 1, full_extent)
+    x = torch.arange(full_extent, dtype=torch.float32).reshape(shape)
+    outputs = []
+
+    for rank in range(world_size):
+        monkeypatch.setattr(wan_spatial_shard, "_rank_world", lambda group, rank=rank: (rank, world_size))
+        token = wan_spatial_shard._SPATIAL_SHARD_CONTEXT.set(
+            wan_spatial_shard.SpatialShardContext(
+                input_extent=full_extent,
+                local_input_extent=local_extent,
+                split_dim=split_dim,
+                rank=rank,
+                world_size=world_size,
+            )
+        )
+        try:
+            out = wan_spatial_shard.reshard_from_trimmed_extent(
+                x,
+                local_extent=local_extent,
+                split_dim=split_dim,
+                group=object(),
+            )
+        finally:
+            wan_spatial_shard._SPATIAL_SHARD_CONTEXT.reset(token)
+
+        start = rank * local_extent
+        valid_extent = min(local_extent, max(0, full_extent - start))
+        expected = torch.zeros(local_extent, dtype=torch.float32)
+        if valid_extent:
+            expected[:valid_extent] = torch.arange(start, start + valid_extent, dtype=torch.float32)
+        assert out.shape[_spatial_dim_for_test(split_dim)] == local_extent
+        assert torch.equal(out.flatten(), expected)
+        outputs.append(out)
+
+    reconstructed = torch.cat(outputs, dim=_spatial_dim_for_test(split_dim))
+    reconstructed = reconstructed.narrow(_spatial_dim_for_test(split_dim), 0, full_extent)
+    assert torch.equal(reconstructed, x)
+
+
+def _spatial_dim_for_test(split_dim: str) -> int:
+    return -2 if split_dim == "height" else -1
+
+
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_reshard_from_trimmed_extent_rejects_rank_mismatch(monkeypatch: pytest.MonkeyPatch):
+    monkeypatch.setattr(wan_spatial_shard, "_rank_world", lambda group: (1, 2))
+    x = torch.zeros((1, 1, 1, 1, 4), dtype=torch.float32)
+    token = wan_spatial_shard._SPATIAL_SHARD_CONTEXT.set(
+        wan_spatial_shard.SpatialShardContext(
+            input_extent=4,
+            local_input_extent=2,
+            split_dim="width",
+            rank=0,
+            world_size=2,
+        )
+    )
+    try:
+        with pytest.raises(RuntimeError, match="group_rank=1, context_rank=0"):
+            wan_spatial_shard.reshard_from_trimmed_extent(
+                x,
+                local_extent=2,
+                split_dim="width",
+                group=object(),
+            )
+    finally:
+        wan_spatial_shard._SPATIAL_SHARD_CONTEXT.reset(token)
+
+
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_attention_wrapper_rejects_spatial_extent_change(monkeypatch: pytest.MonkeyPatch):
+    class ShrinkingWanAttentionBlock(torch.nn.Module):
+        def forward(self, x):
+            return x[..., :-1]
+
+    monkeypatch.setattr(wan_spatial_shard, "_rank_world", lambda group: (0, 2))
+    monkeypatch.setattr(
+        wan_spatial_shard,
+        "all_gather_along_dim",
+        lambda x, *, group, dim, dst=None: torch.cat([x, x], dim=dim),
+    )
+    module = ShrinkingWanAttentionBlock()
+    wan_spatial_shard._patch_attention_block(module, group=object(), split_dim="width")
+    x = torch.zeros((1, 1, 1, 1, 2), dtype=torch.float32)
+    token = wan_spatial_shard._SPATIAL_SHARD_CONTEXT.set(
+        wan_spatial_shard.SpatialShardContext(
+            input_extent=4,
+            local_input_extent=2,
+            split_dim="width",
+            rank=0,
+            world_size=2,
+        )
+    )
+    try:
+        with pytest.raises(
+            RuntimeError,
+            match=r"local_extent=2, gathered_extent=4, trimmed_extent=4, output_extent=3",
+        ):
+            module(x)
+    finally:
+        wan_spatial_shard._SPATIAL_SHARD_CONTEXT.reset(token)
+
+
 @pytest.mark.core_model
 @pytest.mark.cpu
 def test_halo_exchange_single_rank_noop(monkeypatch: pytest.MonkeyPatch):

tests/diffusion/layers/test_fused_moe.py

@@ -110,7 +110,7 @@ class TestFusedMoEFactory:
         monkeypatch.setitem(
             sys.modules,
             "vllm.model_executor.layers.fused_moe",
-            SimpleNamespace(FusedMoE=mock_vllm_fused_moe),
+            SimpleNamespace(FusedMoEFactory=mock_vllm_fused_moe),
         )
 
         result = fused_moe.FusedMoE(prefix="test", a=1, reduce_results=True)
@@ -139,7 +139,7 @@ class TestFusedMoEFactory:
         monkeypatch.setitem(
             sys.modules,
             "vllm.model_executor.layers.fused_moe",
-            SimpleNamespace(FusedMoE=mocker.MagicMock(return_value=mock_runner)),
+            SimpleNamespace(FusedMoEFactory=mocker.MagicMock(return_value=mock_runner)),
         )
         mocker.patch.object(fused_moe, "current_omni_platform", mocker.MagicMock())
         mock_set_num_tokens = mocker.patch.object(fused_moe, "_set_forward_context_num_tokens")
@@ -169,7 +169,7 @@ class TestFusedMoEFactory:
         monkeypatch.setitem(
             sys.modules,
             "vllm.model_executor.layers.fused_moe",
-            SimpleNamespace(FusedMoE=mocker.MagicMock(return_value=mock_runner)),
+            SimpleNamespace(FusedMoEFactory=mocker.MagicMock(return_value=mock_runner)),
         )
         mocker.patch.object(fused_moe, "current_omni_platform", mocker.MagicMock())
         mock_set_num_tokens = mocker.patch.object(fused_moe, "_set_forward_context_num_tokens")

tests/diffusion/lora/test_diffusion_lora.py

@@ -29,10 +29,10 @@ def test_diffusion_model(tmp_path: Path, omni_runner):
             raise ValueError("Empty outputs from Omni.generate()")
         first_output = outputs[0]
         assert first_output.final_output_type == "image"
-        if not hasattr(first_output, "request_output") or not first_output.request_output:
+        if not isinstance(first_output, OmniRequestOutput) or not first_output:
             raise ValueError("No request_output found in OmniRequestOutput")
 
-        req_out = first_output.request_output
+        req_out = first_output
         if not isinstance(req_out, OmniRequestOutput) or not hasattr(req_out, "images"):
             raise ValueError("Invalid request_output structure or missing 'images' key")
         return req_out.images

tests/diffusion/lora/test_loader.py

@@ -0,0 +1,438 @@
+from collections import defaultdict
+
+import pytest
+import torch
+import torch.nn as nn
+from diffusers.loaders.lora_conversion_utils import (
+    _convert_non_diffusers_qwen_lora_to_diffusers,
+)
+from pytest_mock import MockerFixture
+from torch.testing import assert_close
+
+from vllm_omni.diffusion.lora.loader import (
+    LoraLoaderMixin,
+    QwenImageLoraLoaderMixin,
+    WanLoraLoaderMixin,
+    _prepare_lora_delta,
+    _remap_state_dict_keys,
+)
+
+HEAD_DIM = 24
+RANK = 2
+NUM_LAYERS = 10
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class DummyTransformerBlock(nn.Module):
+    def __init__(
+        self,
+        d_model: int,
+        bias: bool = False,
+        stacked_params: bool = False,
+    ):
+        super().__init__()
+        self.attn = nn.Module()
+        if stacked_params:
+            self.attn.to_qkv = nn.Linear(d_model * 3, d_model, bias=bias)
+        else:
+            self.attn.to_q = nn.Linear(d_model, d_model, bias=bias)
+            self.attn.to_k = nn.Linear(d_model, d_model, bias=bias)
+            self.attn.to_v = nn.Linear(d_model, d_model, bias=bias)
+        self.attn.to_out = nn.Linear(d_model, d_model, bias=bias)
+
+
+class DummyTransformer(nn.Module):
+    def __init__(self, num_layers: int, d_model: int, bias: bool = False, stacked_params: bool = False):
+        super().__init__()
+
+        self.blocks = nn.ModuleList(
+            [DummyTransformerBlock(d_model, bias=bias, stacked_params=stacked_params) for _ in range(num_layers)]
+        )
+        if stacked_params:
+            self.stacked_params_mapping = [
+                (".attn.to_qkv", ".attn.to_q", "q"),
+                (".attn.to_qkv", ".attn.to_k", "k"),
+                (".attn.to_qkv", ".attn.to_v", "v"),
+            ]
+
+
+class DummyPipeline(nn.Module, LoraLoaderMixin):
+    def __init__(self, num_layers: int, d_model: int, bias: bool = False, stacked_params: bool = False):
+        super().__init__()
+        self.transformer = DummyTransformer(num_layers, d_model, bias=bias, stacked_params=stacked_params)
+
+
+# ======================================================
+# helper functions for test
+# ======================================================
+def _filter_parameters(named_params, mode: str = "all"):
+    if mode == "all":
+        return named_params
+
+    filtered = []
+    for name, param in named_params:
+        if name.endswith(mode):
+            filtered.append((name, param))
+
+    return filtered
+
+
+def assert_params_equal(module, original_params, mode: str = "all"):
+    for name, param in _filter_parameters(module.named_parameters(), mode):
+        assert_close(param, original_params[name])
+
+
+def assert_params_not_equal(module, original_params, mode: str = "all"):
+    for name, param in _filter_parameters(module.named_parameters(), mode):
+        assert not torch.allclose(param, original_params[name])
+
+
+def make_dummy_lora_state_dict(
+    base_key,
+    weight_a: torch.Tensor | None = None,
+    weight_b: torch.Tensor | None = None,
+    weight_bias: torch.Tensor | None = None,
+    bias: bool = False,
+    lora_a_suffix: str = "lora_A.weight",
+    lora_b_suffix: str = "lora_B.weight",
+    lora_bias_suffix: str = "bias",
+):
+    """
+    Create a dummy LoRA state dict.
+
+    Returns:
+        tuple: (state_dict, expected_delta)
+    """
+    key_a = f"{base_key}.{lora_a_suffix}"
+    key_b = f"{base_key}.{lora_b_suffix}"
+    key_bias = f"{base_key}.{lora_bias_suffix}" if bias else None
+
+    if weight_a is None:
+        weight_a = torch.randn(RANK, HEAD_DIM)
+    if weight_b is None:
+        weight_b = torch.randn(HEAD_DIM, RANK)
+
+    state_dict = {}
+    expected_delta = None
+
+    if bias:
+        state_dict[key_a] = weight_a
+        state_dict[key_b] = weight_b
+        weight_bias = torch.randn(HEAD_DIM)
+        state_dict[key_bias] = weight_bias
+        expected_delta = weight_bias
+    else:
+        state_dict[key_a] = weight_a
+        state_dict[key_b] = weight_b
+        expected_delta = weight_b @ weight_a
+
+    return state_dict, expected_delta
+
+
+def make_lora_state_dict_for_module(
+    module,
+    lora_rank=RANK,
+    bias=False,
+    lora_a_suffix: str = "lora_A.weight",
+    lora_b_suffix: str = "lora_B.weight",
+    lora_bias_suffix: str = "bias",
+    prefix: str = "transformer",
+    remap_proj_out: bool = True,
+):
+    param_to_weight_names = defaultdict(list)
+    if hasattr(module, "stacked_params_mapping"):
+        for param_name, weight_name, _ in module.stacked_params_mapping:
+            param_to_weight_names[param_name].append(weight_name)
+
+    state_dict = {}
+    for name, param in module.named_parameters(prefix=prefix):
+        if name.endswith(".weight"):
+            base_key = name[: -len(".weight")]
+            if remap_proj_out and base_key.endswith(".to_out"):
+                base_key = base_key.replace(".to_out", ".to_out.0")
+
+            d_in, d_out = param.shape
+            is_stacked_param = False
+            for param_name, weight_names in param_to_weight_names.items():
+                if param_name not in name:
+                    continue
+                is_stacked_param = True
+                target_in = d_in // len(weight_names)
+                for weight_name in weight_names:
+                    lora_key = base_key.replace(param_name, weight_name)
+                    weight_a = torch.randn(lora_rank, d_out)
+                    weight_b = torch.randn(target_in, lora_rank)
+                    state_dict[f"{lora_key}.{lora_a_suffix}"] = weight_a
+                    state_dict[f"{lora_key}.{lora_b_suffix}"] = weight_b
+
+            if is_stacked_param:
+                continue
+
+            weight_a = torch.randn(lora_rank, d_out)
+            weight_b = torch.randn(d_in, lora_rank)
+            key_a = f"{base_key}.{lora_a_suffix}"
+            key_b = f"{base_key}.{lora_b_suffix}"
+            state_dict[key_a] = weight_a
+            state_dict[key_b] = weight_b
+        elif name.endswith(".bias") and bias:
+            base_key = name[: -len(".bias")]
+            if remap_proj_out and base_key.endswith(".to_out"):
+                base_key = base_key.replace(".to_out", ".to_out.0")
+
+            d_bias = param.shape[0]
+            is_stacked_param = False
+            for param_name, weight_names in param_to_weight_names.items():
+                if param_name not in name:
+                    continue
+                is_stacked_param = True
+                target_bias = d_bias // len(weight_names)
+                for weight_name in weight_names:
+                    lora_key = base_key.replace(param_name, weight_name)
+                    weight_bias = torch.randn(target_bias)
+                    state_dict[f"{lora_key}.{lora_bias_suffix}"] = weight_bias
+
+            if is_stacked_param:
+                continue
+
+            key_bias = f"{base_key}.{lora_bias_suffix}"
+            state_dict[key_bias] = torch.randn_like(param)
+
+    return state_dict
+
+
+# ======================================================
+# Test loader helper functions
+# ======================================================
+def test_prepare_lora_delta_with_stacked_params():
+    base_key = "transformer.attn.to_qkv"
+
+    sd0, delta0 = make_dummy_lora_state_dict("transformer.attn.to_q")
+    sd1, delta1 = make_dummy_lora_state_dict("transformer.attn.to_k")
+    sd2, delta2 = make_dummy_lora_state_dict("transformer.attn.to_v")
+
+    lora_state_dict = {}
+    lora_state_dict.update(sd0)
+    lora_state_dict.update(sd1)
+    lora_state_dict.update(sd2)
+    expected_delta = torch.concat([delta0, delta1, delta2])
+
+    stacked_mapping = {".attn.to_qkv": [".attn.to_q", ".attn.to_k", ".attn.to_v"]}
+
+    actual_delta, used_keys = _prepare_lora_delta(
+        lora_state_dict,
+        base_key,
+        stacked_mapping,
+    )
+
+    # validate the delta
+    assert actual_delta is not None
+    assert_close(actual_delta, expected_delta)
+
+    # validate the used keys
+    key_q_a = "transformer.attn.to_q.lora_A.weight"
+    key_q_b = "transformer.attn.to_q.lora_B.weight"
+    key_k_a = "transformer.attn.to_k.lora_A.weight"
+    key_k_b = "transformer.attn.to_k.lora_B.weight"
+    key_v_a = "transformer.attn.to_v.lora_A.weight"
+    key_v_b = "transformer.attn.to_v.lora_B.weight"
+
+    for key in [key_q_a, key_q_b, key_k_a, key_k_b, key_v_a, key_v_b]:
+        assert key in used_keys
+
+
+def test_remap_state_dict_keys_matched_two():
+    lora_state_dict, _ = make_dummy_lora_state_dict(
+        "transformer.attn.to_out.0", bias=True, lora_bias_suffix="lora_B.bias"
+    )
+
+    lora_state_dict = _remap_state_dict_keys(
+        lora_state_dict,
+        [(".to_out.0.", ".to_out."), (".lora_B.bias", ".bias")],
+    )
+
+    assert len(lora_state_dict) == 3
+    assert "transformer.attn.to_out.bias" in lora_state_dict
+
+
+# ======================================================
+# Test LoraLoaderMixin
+# ======================================================
+class TestLoraLoaderMixin:
+    @pytest.mark.parametrize(
+        "bias, stacked_params",
+        [
+            (False, False),
+            (True, False),
+            (False, True),
+            (True, True),
+        ],
+        ids=[
+            "basic",
+            "bias",
+            "stacked_params",
+            "bias_stacked_params",
+        ],
+    )
+    def test_load_lora_into_module(self, bias: bool, stacked_params: bool):
+        pipeline = DummyPipeline(NUM_LAYERS, HEAD_DIM, bias=bias, stacked_params=stacked_params)
+        original_params = {name: param.clone() for name, param in pipeline.transformer.named_parameters()}
+
+        lora_state_dict = make_lora_state_dict_for_module(pipeline.transformer, bias=bias)
+        assert len(lora_state_dict) > 0
+
+        # remap the keys to vllm-omni format
+        lora_state_dict = _remap_state_dict_keys(lora_state_dict, [(".to_out.0.", ".to_out.")])
+
+        used_keys = pipeline.load_lora_into_module(lora_state_dict, pipeline.transformer)
+        # validate the parameters are updated
+        assert_params_not_equal(pipeline.transformer, original_params)
+
+        # validate all keys are used
+        missing_keys = set(lora_state_dict.keys()) - used_keys
+        assert len(missing_keys) == 0
+
+    def test_unload_module_lora(self):
+        pipeline = DummyPipeline(NUM_LAYERS, HEAD_DIM)
+        original_params = {name: param.clone() for name, param in pipeline.transformer.named_parameters()}
+
+        lora_state_dict = make_lora_state_dict_for_module(pipeline.transformer)
+        # validate the state dict is valid
+        assert len(lora_state_dict) > 0
+
+        # remap the keys to vllm-omni format
+        lora_state_dict = _remap_state_dict_keys(lora_state_dict, [(".to_out.0.", ".to_out.")])
+
+        used_keys = pipeline.load_lora_into_module(lora_state_dict, pipeline.transformer)
+
+        # validate the weights are updated
+        assert_params_not_equal(pipeline.transformer, original_params)
+
+        # validate all keys are used
+        missing_keys = set(lora_state_dict.keys()) - used_keys
+        assert len(missing_keys) == 0
+
+        unload_used_keys = pipeline.unload_module_lora(lora_state_dict, pipeline.transformer)
+        missing_keys = set(lora_state_dict.keys()) - unload_used_keys
+        assert len(missing_keys) == 0
+        assert len(unload_used_keys - used_keys) == 0
+
+        # validate the weights are restored
+        assert_params_equal(pipeline.transformer, original_params)
+
+
+# ======================================================
+# Test QwenImageLoraLoaderMixin
+# ======================================================
+class DummyQwenImagePipeline(nn.Module, QwenImageLoraLoaderMixin):
+    def __init__(self, num_layers: int, d_model: int, bias: bool = False):
+        super().__init__()
+        self.transformer = DummyTransformer(num_layers, d_model, bias=bias, stacked_params=True)
+
+
+class TestQwenImageLoraLoaderMixin:
+    def test_load_lora_weights(self, mocker: MockerFixture):
+        pipeline = DummyQwenImagePipeline(NUM_LAYERS, HEAD_DIM)
+        original_params = {name: param.clone() for name, param in pipeline.transformer.named_parameters()}
+
+        lora_state_dict = make_lora_state_dict_for_module(pipeline.transformer)
+        assert len(lora_state_dict) > 0
+
+        mocker.patch(
+            "vllm_omni.diffusion.lora.loader.get_converter_by_pipeline",
+            return_value=_convert_non_diffusers_qwen_lora_to_diffusers,
+        )
+        pipeline.load_lora_weights(lora_state_dict, "adapter0")
+
+        # validate the weights are updated after lora loaded
+        assert_params_not_equal(pipeline.transformer, original_params)
+
+        # validate lora_loaded map is updated after lora loaded
+        assert "adapter0" in pipeline.lora_loaded
+
+    def test_unload_lora_weights(self, mocker: MockerFixture):
+        pipeline = DummyQwenImagePipeline(NUM_LAYERS, HEAD_DIM)
+        original_params = {name: param.clone() for name, param in pipeline.transformer.named_parameters()}
+
+        lora_state_dict = make_lora_state_dict_for_module(pipeline.transformer)
+        assert len(lora_state_dict) > 0
+
+        mocker.patch(
+            "vllm_omni.diffusion.lora.loader.get_converter_by_pipeline",
+            return_value=_convert_non_diffusers_qwen_lora_to_diffusers,
+        )
+        pipeline.load_lora_weights(lora_state_dict, "adapter0")
+        # validate the weights are updated after lora loaded
+        assert_params_not_equal(pipeline.transformer, original_params)
+
+        # validate lora_loaded map is updated after lora loaded
+        assert "adapter0" in pipeline.lora_loaded
+
+        pipeline.unload_lora_weights("adapter0")
+        # validate the weights are restored after lora unloaded
+        assert_params_equal(pipeline.transformer, original_params)
+
+        # validate lora_loaded map is updated
+        assert "adapter0" not in pipeline.lora_loaded
+
+    def test_load_diffusers_lora_applies_non_unit_alpha(self, mocker: MockerFixture):
+        pipeline = DummyQwenImagePipeline(1, HEAD_DIM)
+        to_out = pipeline.transformer.blocks[0].attn.to_out
+        original_weight = to_out.weight.detach().clone()
+        base_key = "blocks.0.attn.to_out.0"
+        lora_a = torch.randn(RANK, HEAD_DIM)
+        lora_b = torch.randn(HEAD_DIM, RANK)
+        alpha = torch.tensor(6.0)
+        state_dict = {
+            f"{base_key}.lora_A.weight": lora_a,
+            f"{base_key}.lora_B.weight": lora_b,
+            f"{base_key}.alpha": alpha,
+        }
+        mocker.patch(
+            "vllm_omni.diffusion.lora.loader.get_converter_by_pipeline",
+            return_value=_convert_non_diffusers_qwen_lora_to_diffusers,
+        )
+
+        pipeline.load_lora_weights(state_dict, "adapter0")
+
+        expected_weight = original_weight + (lora_b @ lora_a) * (alpha.item() / RANK)
+        assert_close(to_out.weight, expected_weight)
+
+        pipeline.unload_lora_weights("adapter0")
+        assert_close(to_out.weight, original_weight)
+
+
+# ======================================================
+# Test WanLoraLoaderMixin
+# ======================================================
+class DummyWanPipeline(nn.Module, WanLoraLoaderMixin):
+    def __init__(self, num_layers: int, d_model: int):
+        super().__init__()
+        self.has_transformer_2 = True
+        self.transformer = DummyTransformer(num_layers, d_model, stacked_params=True)
+        self.transformer_2 = DummyTransformer(num_layers, d_model, stacked_params=True)
+
+
+def test_wan_load_lora_weights_targets_both_transformers(mocker: MockerFixture):
+    pipeline = DummyWanPipeline(NUM_LAYERS, HEAD_DIM)
+    original_high = {name: param.clone() for name, param in pipeline.transformer.named_parameters()}
+    original_low = {name: param.clone() for name, param in pipeline.transformer_2.named_parameters()}
+    high_state_dict = make_lora_state_dict_for_module(pipeline.transformer)
+    low_state_dict = make_lora_state_dict_for_module(pipeline.transformer_2)
+
+    mocker.patch(
+        "vllm_omni.diffusion.lora.loader._load_lora_state_dict",
+        side_effect=[high_state_dict, low_state_dict],
+    )
+
+    pipeline.load_lora_weights(["high.safetensors", "low.safetensors"], "adapter0")
+
+    assert_params_not_equal(pipeline.transformer, original_high)
+    assert_params_not_equal(pipeline.transformer_2, original_low)
+    assert set(pipeline.lora_loaded["adapter0"]) == {"transformer", "transformer_2"}
+
+    pipeline.unload_lora_weights("adapter0")
+
+    assert_params_equal(pipeline.transformer, original_high)
+    assert_params_equal(pipeline.transformer_2, original_low)
+    assert "adapter0" not in pipeline.lora_loaded

tests/diffusion/models/lingbot_video/test_request_utils.py

@@ -348,3 +348,53 @@ def test_normalize_lingbot_request_model_size_overrides_sampling_dimensions():
         num_frames=81,
     )
     assert (config.height, config.width) == (480, 480)
+
+
+def test_normalize_lingbot_request_reads_size_from_extra_args():
+    """Regression: /v1/videos delivers `extra_params` via sampling.extra_args.
+
+    The nightly TI2V case sends `extra_params={"size": "320x192"}` with no
+    height/width form fields; the size used to be dropped and the video came
+    out at the 480x480 default (build 2952, LingBot Video MoE Function Test).
+    """
+    config = _normalize(
+        {
+            "prompt": "motion",
+            "modalities": ["video"],
+            "multi_modal_data": {"image": Image.new("RGB", (320, 192))},
+        },
+        num_frames=9,
+        extra_args={"size": "320x192"},
+    )
+    assert config.mode is LingBotGenerationMode.TI2V
+    assert (config.height, config.width) == (192, 320)
+
+
+def test_normalize_lingbot_request_extra_args_size_overrides_sampling_dimensions():
+    config = _normalize(
+        {"prompt": "motion", "modalities": ["video"]},
+        width=480,
+        height=480,
+        num_frames=81,
+        extra_args={"size": "320x192"},
+    )
+    assert (config.height, config.width) == (192, 320)
+
+
+def test_normalize_lingbot_request_reads_width_height_from_extra_args():
+    # Parity with the pre-#5311 pipeline, which honored extra_args height/width.
+    config = _normalize(
+        {"prompt": "motion", "modalities": ["video"]},
+        num_frames=81,
+        extra_args={"width": 320, "height": 192},
+    )
+    assert (config.height, config.width) == (192, 320)
+
+
+def test_resolve_lingbot_output_dimensions_reads_extra_fields():
+    assert resolve_lingbot_output_dimensions(extra_fields={"size": "320x192"}) == (320, 192)
+    assert resolve_lingbot_output_dimensions(
+        sampling_width=480,
+        sampling_height=480,
+        extra_fields={"resolution": "720p", "ratio": "16:9"},
+    ) == (736, 1280)

tests/diffusion/models/ltx2/test_ltx2_vae.py

@@ -11,6 +11,100 @@ import torch
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 
+class TestLTXChannelsLast3D:
+    @pytest.mark.parametrize(
+        ("extras", "expected"),
+        [({}, False), ({"ltx2_use_channels_last_3d": True}, True)],
+    )
+    def test_channels_last_opt_in_is_ltx2_model_extra(self, extras, expected):
+        from vllm_omni.diffusion.models.ltx2.ltx2_components import _ltx2_use_channels_last_3d
+
+        assert _ltx2_use_channels_last_3d(SimpleNamespace(extras=extras)) is expected
+
+    def test_channels_last_opt_in_rejects_non_boolean_model_extra(self):
+        from vllm_omni.diffusion.models.ltx2.ltx2_components import _ltx2_use_channels_last_3d
+
+        with pytest.raises(TypeError, match="ltx2_use_channels_last_3d"):
+            _ltx2_use_channels_last_3d(SimpleNamespace(extras={"ltx2_use_channels_last_3d": "true"}))
+
+    @pytest.mark.parametrize(
+        ("causal", "kernel_size"),
+        [
+            (True, 3),
+            (False, 3),
+            (True, (3, 1, 1)),
+            (True, 1),
+        ],
+    )
+    def test_layout_preserving_causal_conv_matches_original(self, causal, kernel_size):
+        from diffusers.models.autoencoders.autoencoder_kl_ltx2 import LTX2VideoCausalConv3d
+
+        from vllm_omni.diffusion.distributed.autoencoders.autoencoder_kl_ltx2 import (
+            _enable_channels_last_3d,
+            _weight_is_channels_last_3d,
+        )
+
+        torch.manual_seed(0)
+        conv = LTX2VideoCausalConv3d(4, 5, kernel_size).to(dtype=torch.float32).eval()
+        hidden_states = torch.randn(1, 4, 5, 6, 7, dtype=torch.float32)
+
+        # Pointwise Conv3d storage is valid in both contiguous formats because
+        # all spatial/temporal kernel dimensions are singleton.
+        if kernel_size != 1:
+            assert not _weight_is_channels_last_3d(conv)
+        with torch.no_grad():
+            expected = conv(hidden_states.clone(), causal=causal)
+
+        converted, patched = _enable_channels_last_3d(conv)
+
+        assert (converted, patched) == (1, 1)
+        assert _weight_is_channels_last_3d(conv)
+        with torch.no_grad():
+            actual = conv(hidden_states.clone(), causal=causal)
+
+        torch.testing.assert_close(actual, expected, rtol=1e-4, atol=1e-4)
+
+    def test_temporal_pad_replicates_edges_in_channels_last_3d(self):
+        from vllm_omni.diffusion.distributed.autoencoders.autoencoder_kl_ltx2 import (
+            _temporal_pad_channels_last_3d,
+        )
+
+        torch.manual_seed(0)
+        hidden_states = torch.randn(1, 4, 3, 2, 2, dtype=torch.float32)
+
+        actual = _temporal_pad_channels_last_3d(hidden_states, left=2, right=1)
+        expected = torch.cat(
+            [
+                hidden_states[:, :, :1].repeat(1, 1, 2, 1, 1),
+                hidden_states,
+                hidden_states[:, :, -1:],
+            ],
+            dim=2,
+        )
+
+        assert actual.is_contiguous(memory_format=torch.channels_last_3d)
+        torch.testing.assert_close(actual, expected, rtol=0, atol=0)
+
+    def test_contiguous_weight_keeps_original_padding_path(self, monkeypatch):
+        from diffusers.models.autoencoders.autoencoder_kl_ltx2 import LTX2VideoCausalConv3d
+
+        import vllm_omni.diffusion.distributed.autoencoders.autoencoder_kl_ltx2 as ltx2_vae
+
+        conv = LTX2VideoCausalConv3d(4, 5, 3).to(dtype=torch.float32).eval()
+        hidden_states = torch.randn(1, 4, 3, 2, 2, dtype=torch.float32)
+
+        def fail_channels_last_pad(*_args, **_kwargs):
+            raise AssertionError("contiguous weights must retain the original padding path")
+
+        monkeypatch.setattr(ltx2_vae, "_temporal_pad_channels_last_3d", fail_channels_last_pad)
+
+        with torch.no_grad():
+            expected = conv(hidden_states, causal=True)
+            actual = ltx2_vae._layout_preserving_causal_conv_forward(conv, hidden_states, causal=True)
+
+        torch.testing.assert_close(actual, expected, rtol=0, atol=0)
+
+
 class TestLTXOutputRank:
     @pytest.mark.parametrize(
         ("distributed_vae_state", "expected_decode_calls"),

tests/diffusion/models/minimax_h3/test_minimax_h3_rmsnorm.py

@@ -0,0 +1,26 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import torch
+
+from vllm_omni.diffusion.layers.norm import RMSNorm
+from vllm_omni.diffusion.models.minimax_h3.encoder import MiniMaxH3Qwen3VLRMSNorm
+
+
+def test_qwen3_vl_rmsnorm_uses_common_fused_rmsnorm_contract() -> None:
+    """Qwen keeps BF16 gamma while native fallback accumulates in FP32."""
+    eps = 1e-6
+    norm = MiniMaxH3Qwen3VLRMSNorm(hidden_size=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], [-5.0, 6.0, -7.0, 8.0]],
+        dtype=torch.bfloat16,
+    )
+
+    x_fp32 = x.float()
+    expected = (x_fp32 * torch.rsqrt(x_fp32.square().mean(-1, keepdim=True) + eps) * norm.weight.float()).to(x.dtype)
+
+    assert isinstance(norm, RMSNorm)
+    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)

tests/diffusion/offloader/test_diffusion_cpu_offload.py

@@ -122,8 +122,8 @@ def test_cpu_offload_diffusion_model(model_name: str):
     print(f"No offload peak memory: {no_offload_peak_memory} MB")
 
     if model_name == "stabilityai/stable-audio-open-1.0":
-        audio_offload = output_offload[0].request_output.multimodal_output.get("audio")
-        audio_no_offload = output_no_offload[0].request_output.multimodal_output.get("audio")
+        audio_offload = output_offload[0].multimodal_output.get("audio")
+        audio_no_offload = output_no_offload[0].multimodal_output.get("audio")
         check_audio_determinism(audio_offload, audio_no_offload, atol=1e-2)
 
     # Set platform-specific VRAM saving thresholds to account